/*
 * Module code.
 *
 * Generated by SIP 4.16.8
 *
 * Copyright (c) 2015 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt4.
 * 
 * This file may be used under the terms of the GNU General Public License
 * version 3.0 as published by the Free Software Foundation and appearing in
 * the file LICENSE included in the packaging of this file.  Please review the
 * following information to ensure the GNU General Public License version 3.0
 * requirements will be met: http://www.gnu.org/copyleft/gpl.html.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPIQtSql.h"

#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqltablemodel.sip"
#include <qsqltablemodel.h>
#line 35 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 38 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 41 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 44 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 47 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrelationaltablemodel.sip"
#include <qsqlrelationaltablemodel.h>
#line 50 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlresult.sip"
#include <qsqlresult.h>
#line 53 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldriver.sip"
#include <qsqldriver.h>
#line 56 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlfield.sip"
#include <qsqlfield.h>
#line 59 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlindex.sip"
#include <qsqlindex.h>
#line 62 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 65 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 68 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 71 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlquery.sip"
#include <qsqlquery.h>
#line 74 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_QtSql[] = {
    'u', 'n', 's', 'u', 'b', 's', 'c', 'r', 'i', 'b', 'e', 'F', 'r', 'o', 'm', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 0,
    's', 'u', 'b', 's', 'c', 'r', 'i', 'b', 'e', 'd', 'T', 'o', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 's', 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 0,
    's', 'u', 'b', 's', 'c', 'r', 'i', 'b', 'e', 'T', 'o', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 0,
    'Q', 'S', 'q', 'l', 'R', 'e', 'l', 'a', 't', 'i', 'o', 'n', 'a', 'l', 'T', 'a', 'b', 'l', 'e', 'M', 'o', 'd', 'e', 'l', ':', ':', 'J', 'o', 'i', 'n', 'M', 'o', 'd', 'e', 0,
    'i', 's', 'I', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 'E', 's', 'c', 'a', 'p', 'e', 'd', 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 0,
    'Q', 'S', 'q', 'l', ':', ':', 'N', 'u', 'm', 'e', 'r', 'i', 'c', 'a', 'l', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 'P', 'o', 'l', 'i', 'c', 'y', 0,
    'Q', 'S', 'q', 'l', 'Q', 'u', 'e', 'r', 'y', ':', ':', 'B', 'a', 't', 'c', 'h', 'E', 'x', 'e', 'c', 'u', 't', 'i', 'o', 'n', 'M', 'o', 'd', 'e', 0,
    's', 't', 'r', 'i', 'p', 'D', 'e', 'l', 'i', 'm', 'i', 't', 'e', 'r', 's', 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 0,
    'Q', 'S', 'q', 'l', 'T', 'a', 'b', 'l', 'e', 'M', 'o', 'd', 'e', 'l', ':', ':', 'E', 'd', 'i', 't', 'S', 't', 'r', 'a', 't', 'e', 'g', 'y', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'C', 'o', 'r', 'e', '.', 'p', 'y', 'q', 't', 'W', 'r', 'a', 'p', 'p', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'u', 'n', 's', 'u', 'b', 's', 'c', 'r', 'i', 'b', 'e', 'F', 'r', 'o', 'm', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'N', 'u', 'm', 'e', 'r', 'i', 'c', 'a', 'l', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 'P', 'o', 'l', 'i', 'c', 'y', 0,
    'Q', 'S', 'q', 'l', 'D', 'r', 'i', 'v', 'e', 'r', ':', ':', 'I', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'Q', 'S', 'q', 'l', 'R', 'e', 's', 'u', 'l', 't', ':', ':', 'B', 'i', 'n', 'd', 'i', 'n', 'g', 'S', 'y', 'n', 't', 'a', 'x', 0,
    'Q', 'S', 'q', 'l', 'F', 'i', 'e', 'l', 'd', ':', ':', 'R', 'e', 'q', 'u', 'i', 'r', 'e', 'd', 'S', 't', 'a', 't', 'u', 's', 0,
    's', 'u', 'b', 's', 'c', 'r', 'i', 'b', 'e', 'd', 'T', 'o', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 's', 0,
    'Q', 'S', 'q', 'l', 'D', 'r', 'i', 'v', 'e', 'r', ':', ':', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 'T', 'y', 'p', 'e', 0,
    'Q', 'S', 'q', 'l', 'D', 'r', 'i', 'v', 'e', 'r', ':', ':', 'D', 'r', 'i', 'v', 'e', 'r', 'F', 'e', 'a', 't', 'u', 'r', 'e', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'P', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 'I', 'n', 'd', 'e', 'x', 'L', 'i', 's', 't', 0,
    'Q', 'S', 'q', 'l', 'R', 'e', 'l', 'a', 't', 'i', 'o', 'n', 'a', 'l', 'T', 'a', 'b', 'l', 'e', 'M', 'o', 'd', 'e', 'l', 0,
    'n', 'u', 'm', 'e', 'r', 'i', 'c', 'a', 'l', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 'P', 'o', 'l', 'i', 'c', 'y', 0,
    's', 'u', 'b', 's', 'c', 'r', 'i', 'b', 'e', 'T', 'o', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'Q', 'S', 'q', 'l', 'R', 'e', 'l', 'a', 't', 'i', 'o', 'n', 'a', 'l', 'D', 'e', 'l', 'e', 'g', 'a', 't', 'e', 0,
    'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'P', 'l', 'a', 'c', 'e', 'h', 'o', 'l', 'd', 'e', 'r', 's', 0,
    'Q', 'S', 'q', 'l', 'D', 'r', 'i', 'v', 'e', 'r', 'C', 'r', 'e', 'a', 't', 'o', 'r', 'B', 'a', 's', 'e', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'P', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 'I', 'n', 'd', 'e', 'x', 0,
    'Q', 'S', 'q', 'l', 'E', 'r', 'r', 'o', 'r', ':', ':', 'E', 'r', 'r', 'o', 'r', 'T', 'y', 'p', 'e', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'E', 'd', 'i', 't', 'o', 'r', 'G', 'e', 'o', 'm', 'e', 't', 'r', 'y', 0,
    's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'D', 'r', 'o', 'p', 'A', 'c', 't', 'i', 'o', 'n', 's', 0,
    'i', 's', 'I', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 'E', 's', 'c', 'a', 'p', 'e', 'd', 0,
    'r', 'o', 'l', 'l', 'b', 'a', 'c', 'k', 'T', 'r', 'a', 'n', 's', 'a', 'c', 't', 'i', 'o', 'n', 0,
    'L', 'o', 'w', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 's', 0,
    'Q', 'S', 'q', 'l', ':', ':', 'P', 'a', 'r', 'a', 'm', 'T', 'y', 'p', 'e', 'F', 'l', 'a', 'g', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'B', 'u', 't', 't', 'o', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'p', 'e', 'r', 's', 'i', 's', 't', 'e', 'n', 't', 'I', 'n', 'd', 'e', 'x', 'L', 'i', 's', 't', 0,
    'd', 'e', 'l', 'e', 't', 'e', 'R', 'o', 'w', 'F', 'r', 'o', 'm', 'T', 'a', 'b', 'l', 'e', 0,
    'i', 'n', 's', 'e', 'r', 't', 'R', 'o', 'w', 'I', 'n', 't', 'o', 'T', 'a', 'b', 'l', 'e', 0,
    'M', 'u', 'l', 't', 'i', 'p', 'l', 'e', 'R', 'e', 's', 'u', 'l', 't', 'S', 'e', 't', 's', 0,
    'E', 'v', 'e', 'n', 't', 'N', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 's', 0,
    'L', 'o', 'w', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 'D', 'o', 'u', 'b', 'l', 'e', 0,
    'e', 's', 'c', 'a', 'p', 'e', 'B', 'u', 't', 't', 'o', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'b', 'e', 'g', 'i', 'n', 'R', 'e', 'm', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'b', 'e', 'g', 'i', 'n', 'I', 'n', 's', 'e', 'r', 't', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'Q', 'V', 'e', 'c', 't', 'o', 'r', '<', 'Q', 'V', 'a', 'r', 'i', 'a', 'n', 't', '>', 0,
    'P', 'o', 's', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'B', 'i', 'n', 'd', 'i', 'n', 'g', 0,
    's', 'e', 't', 'R', 'e', 'q', 'u', 'i', 'r', 'e', 'd', 'S', 't', 'a', 't', 'u', 's', 0,
    'c', 'o', 'm', 'm', 'i', 't', 'T', 'r', 'a', 'n', 's', 'a', 'c', 't', 'i', 'o', 'n', 0,
    'N', 'a', 'm', 'e', 'd', 'P', 'l', 'a', 'c', 'e', 'h', 'o', 'l', 'd', 'e', 'r', 's', 0,
    'i', 's', 'D', 'r', 'i', 'v', 'e', 'r', 'A', 'v', 'a', 'i', 'l', 'a', 'b', 'l', 'e', 0,
    'r', 'e', 'g', 'i', 's', 't', 'e', 'r', 'S', 'q', 'l', 'D', 'r', 'i', 'v', 'e', 'r', 0,
    's', 'e', 't', 'C', 'o', 'n', 'n', 'e', 'c', 't', 'O', 'p', 't', 'i', 'o', 'n', 's', 0,
    'L', 'o', 'w', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 'I', 'n', 't', '6', '4', 0,
    'L', 'o', 'w', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 'I', 'n', 't', '3', '2', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'S', 'u', 'b', 'W', 'i', 'n', 'd', 'o', 'w', 's', 0,
    's', 'e', 'n', 'd', 'e', 'r', 'S', 'i', 'g', 'n', 'a', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    'r', 'e', 's', 'e', 't', 'I', 'n', 't', 'e', 'r', 'n', 'a', 'l', 'D', 'a', 't', 'a', 0,
    's', 'i', 'p', '.', 's', 'i', 'm', 'p', 'l', 'e', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'R', 'o', 'w', 'I', 'n', 'T', 'a', 'b', 'l', 'e', 0,
    'T', 'r', 'a', 'n', 's', 'a', 'c', 't', 'i', 'o', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    'e', 's', 'c', 'a', 'p', 'e', 'I', 'd', 'e', 'n', 't', 'i', 'f', 'i', 'e', 'r', 0,
    'b', 'e', 'g', 'i', 'n', 'T', 'r', 'a', 'n', 's', 'a', 'c', 't', 'i', 'o', 'n', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'O', 'l', 'd', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    'b', 'e', 'g', 'i', 'n', 'M', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'e', 'n', 'd', 'R', 'e', 'm', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'e', 'n', 'd', 'I', 'n', 's', 'e', 'r', 't', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    's', 'e', 't', 'E', 'd', 'i', 't', 'S', 't', 'r', 'a', 't', 'e', 'g', 'y', 0,
    'b', 'o', 'u', 'n', 'd', 'V', 'a', 'l', 'u', 'e', 'C', 'o', 'u', 'n', 't', 0,
    's', 'e', 'l', 'e', 'c', 't', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 0,
    'n', 'u', 'm', 'R', 'o', 'w', 's', 'A', 'f', 'f', 'e', 'c', 't', 'e', 'd', 0,
    'V', 'a', 'l', 'u', 'e', 's', 'A', 's', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    's', 'e', 't', 'D', 'e', 'f', 'a', 'u', 'l', 't', 'V', 'a', 'l', 'u', 'e', 0,
    's', 'e', 't', 'D', 'a', 't', 'a', 'b', 'a', 's', 'e', 'T', 'e', 'x', 't', 0,
    'C', 'o', 'n', 'n', 'e', 'c', 't', 'i', 'o', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    's', 't', 'r', 'i', 'p', 'D', 'e', 'l', 'i', 'm', 'i', 't', 'e', 'r', 's', 0,
    'D', 'e', 'l', 'e', 't', 'e', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 0,
    'I', 'n', 's', 'e', 'r', 't', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 0,
    'U', 'p', 'd', 'a', 't', 'e', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 0,
    'S', 'e', 'l', 'e', 'c', 't', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 0,
    'B', 'a', 't', 'c', 'h', 'O', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 's', 0,
    'P', 'r', 'e', 'p', 'a', 'r', 'e', 'd', 'Q', 'u', 'e', 'r', 'i', 'e', 's', 0,
    'c', 'o', 'n', 'n', 'e', 'c', 't', 'i', 'o', 'n', 'N', 'a', 'm', 'e', 's', 0,
    's', 'e', 't', 'D', 'a', 't', 'a', 'b', 'a', 's', 'e', 'N', 'a', 'm', 'e', 0,
    'Q', 'S', 'q', 'l', ':', ':', 'T', 'a', 'b', 'l', 'e', 'T', 'y', 'p', 'e', 0,
    'Q', 'S', 'q', 'l', ':', ':', 'P', 'a', 'r', 'a', 'm', 'T', 'y', 'p', 'e', 0,
    'a', 's', 'p', 'e', 'c', 't', 'R', 'a', 't', 'i', 'o', 'M', 'o', 'd', 'e', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 0,
    'b', 'e', 'g', 'i', 'n', 'R', 'e', 's', 'e', 't', 'M', 'o', 'd', 'e', 'l', 0,
    'b', 'e', 'g', 'i', 'n', 'R', 'e', 'm', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'b', 'e', 'g', 'i', 'n', 'I', 'n', 's', 'e', 'r', 't', 'R', 'o', 'w', 's', 0,
    'O', 'n', 'M', 'a', 'n', 'u', 'a', 'l', 'S', 'u', 'b', 'm', 'i', 't', 0,
    'b', 'o', 'u', 'n', 'd', 'V', 'a', 'l', 'u', 'e', 'N', 'a', 'm', 'e', 0,
    'Q', 'S', 'q', 'l', 'T', 'a', 'b', 'l', 'e', 'M', 'o', 'd', 'e', 'l', 0,
    'Q', 'S', 'q', 'l', 'Q', 'u', 'e', 'r', 'y', 'M', 'o', 'd', 'e', 'l', 0,
    's', 'e', 't', 'F', 'o', 'r', 'w', 'a', 'r', 'd', 'O', 'n', 'l', 'y', 0,
    'r', 'e', 'q', 'u', 'i', 'r', 'e', 'd', 'S', 't', 'a', 't', 'u', 's', 0,
    'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 'E', 'r', 'r', 'o', 'r', 0,
    'W', 'h', 'e', 'r', 'e', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'D', 'a', 't', 'a', 'b', 'a', 's', 'e', 0,
    'c', 'o', 'n', 'n', 'e', 'c', 't', 'i', 'o', 'n', 'N', 'a', 'm', 'e', 0,
    'c', 'o', 'n', 'n', 'e', 'c', 't', 'O', 'p', 't', 'i', 'o', 'n', 's', 0,
    'B', 'e', 'f', 'o', 'r', 'e', 'F', 'i', 'r', 's', 't', 'R', 'o', 'w', 0,
    'Q', 'S', 'q', 'l', ':', ':', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'd', 'r', 'a', 'w', 'D', 'e', 'c', 'o', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'd', 'r', 'a', 'w', 'B', 'a', 'c', 'k', 'g', 'r', 'o', 'u', 'n', 'd', 0,
    's', 'e', 'l', 'e', 'c', 't', 'e', 'd', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'e', 'n', 'd', 'M', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    's', 'e', 't', 'P', 'r', 'i', 'm', 'a', 'r', 'y', 'K', 'e', 'y', 0,
    'O', 'n', 'F', 'i', 'e', 'l', 'd', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    'f', 'e', 't', 'c', 'h', 'P', 'r', 'e', 'v', 'i', 'o', 'u', 's', 0,
    'b', 'i', 'n', 'd', 'i', 'n', 'g', 'S', 'y', 'n', 't', 'a', 'x', 0,
    'b', 'i', 'n', 'd', 'V', 'a', 'l', 'u', 'e', 'T', 'y', 'p', 'e', 0,
    'o', 'r', 'd', 'e', 'r', 'B', 'y', 'C', 'l', 'a', 'u', 's', 'e', 0,
    'r', 'e', 'l', 'a', 't', 'i', 'o', 'n', 'M', 'o', 'd', 'e', 'l', 0,
    'd', 'i', 's', 'p', 'l', 'a', 'y', 'C', 'o', 'l', 'u', 'm', 'n', 0,
    'e', 'x', 'e', 'c', 'u', 't', 'e', 'd', 'Q', 'u', 'e', 'r', 'y', 0,
    'i', 's', 'F', 'o', 'r', 'w', 'a', 'r', 'd', 'O', 'n', 'l', 'y', 0,
    's', 'e', 't', 'D', 'e', 's', 'c', 'e', 'n', 'd', 'i', 'n', 'g', 0,
    's', 'e', 't', 'C', 'u', 'r', 's', 'o', 'r', 'N', 'a', 'm', 'e', 0,
    's', 'e', 't', 'D', 'r', 'i', 'v', 'e', 'r', 'T', 'e', 'x', 't', 0,
    'S', 'i', 'm', 'p', 'l', 'e', 'L', 'o', 'c', 'k', 'i', 'n', 'g', 0,
    'c', 'l', 'o', 'n', 'e', 'D', 'a', 't', 'a', 'b', 'a', 's', 'e', 0,
    'H', 'i', 'g', 'h', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'd', 'S', 'i', 'g', 'n', 'a', 'l', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    't', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'M', 'o', 'd', 'e', 0,
    't', 'h', 'r', 'e', 's', 'h', 'o', 'l', 'd', 'T', 'i', 'm', 'e', 0,
    's', 'e', 't', 'E', 'd', 'i', 't', 'o', 'r', 'D', 'a', 't', 'a', 0,
    'e', 'n', 'd', 'R', 'e', 's', 'e', 't', 'M', 'o', 'd', 'e', 'l', 0,
    'b', 'e', 'g', 'i', 'n', 'M', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'e', 'n', 'd', 'R', 'e', 'm', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'e', 'n', 'd', 'I', 'n', 's', 'e', 'r', 't', 'R', 'o', 'w', 's', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    'i', 'n', 's', 'e', 'r', 't', 'C', 'o', 'l', 'u', 'm', 'n', 's', 0,
    's', 'e', 't', 'H', 'e', 'a', 'd', 'e', 'r', 'D', 'a', 't', 'a', 0,
    'b', 'e', 'f', 'o', 'r', 'e', 'D', 'e', 'l', 'e', 't', 'e', 0,
    'b', 'e', 'f', 'o', 'r', 'e', 'U', 'p', 'd', 'a', 't', 'e', 0,
    'b', 'e', 'f', 'o', 'r', 'e', 'I', 'n', 's', 'e', 'r', 't', 0,
    'i', 'n', 's', 'e', 'r', 't', 'R', 'e', 'c', 'o', 'r', 'd', 0,
    'e', 'd', 'i', 't', 'S', 't', 'r', 'a', 't', 'e', 'g', 'y', 0,
    'h', 'a', 's', 'O', 'u', 't', 'V', 'a', 'l', 'u', 'e', 's', 0,
    'N', 'a', 'm', 'e', 'd', 'B', 'i', 'n', 'd', 'i', 'n', 'g', 0,
    'Q', 'S', 'q', 'l', 'R', 'e', 'l', 'a', 't', 'i', 'o', 'n', 0,
    'i', 'n', 'd', 'e', 'x', 'I', 'n', 'Q', 'u', 'e', 'r', 'y', 0,
    'l', 'a', 's', 't', 'I', 'n', 's', 'e', 'r', 't', 'I', 'd', 0,
    'a', 'd', 'd', 'B', 'i', 'n', 'd', 'V', 'a', 'l', 'u', 'e', 0,
    'V', 'a', 'l', 'u', 'e', 's', 'A', 's', 'R', 'o', 'w', 's', 0,
    'i', 's', 'D', 'e', 's', 'c', 'e', 'n', 'd', 'i', 'n', 'g', 0,
    's', 'e', 't', 'A', 'u', 't', 'o', 'V', 'a', 'l', 'u', 'e', 0,
    's', 'e', 't', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 0,
    's', 'e', 't', 'P', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'd', 'a', 't', 'a', 'b', 'a', 's', 'e', 'T', 'e', 'x', 't', 0,
    'n', 'o', 't', 'i', 'f', 'i', 'c', 'a', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'L', 'a', 's', 't', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'O', 'p', 'e', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'R', 'e', 's', 'u', 'l', 't', 0,
    's', 'q', 'l', 'S', 't', 'a', 't', 'e', 'm', 'e', 'n', 't', 0,
    'L', 'a', 's', 't', 'I', 'n', 's', 'e', 'r', 't', 'I', 'd', 0,
    'T', 'r', 'a', 'n', 's', 'a', 'c', 't', 'i', 'o', 'n', 's', 0,
    'd', 'a', 't', 'a', 'b', 'a', 's', 'e', 'N', 'a', 'm', 'e', 0,
    'p', 'r', 'i', 'm', 'a', 'r', 'y', 'I', 'n', 'd', 'e', 'x', 0,
    'Q', 'S', 'q', 'l', 'D', 'a', 't', 'a', 'b', 'a', 's', 'e', 0,
    'S', 'y', 's', 't', 'e', 'm', 'T', 'a', 'b', 'l', 'e', 's', 0,
    'A', 'f', 't', 'e', 'r', 'L', 'a', 's', 't', 'R', 'o', 'w', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'R', 'e', 'g', 'i', 'o', 'n', 0,
    't', 'a', 'r', 'g', 'e', 't', 'O', 'f', 'f', 's', 'e', 't', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'O', 'b', 'j', 'e', 'c', 't', 0,
    'b', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'R', 'e', 'c', 't', 0,
    'm', 'i', 'd', 'L', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    's', 'e', 't', 'M', 'o', 'd', 'e', 'l', 'D', 'a', 't', 'a', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'E', 'd', 'i', 't', 'o', 'r', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'V', 'a', 'l', 'u', 'e', 0,
    'U', 'n', 'k', 'n', 'o', 'w', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'R', 'o', 'l', 'e', 'N', 'a', 'm', 'e', 's', 0,
    'c', 'a', 'n', 'F', 'e', 't', 'c', 'h', 'M', 'o', 'r', 'e', 0,
    'd', 'r', 'o', 'p', 'M', 'i', 'm', 'e', 'D', 'a', 't', 'a', 0,
    'p', 'r', 'i', 'm', 'e', 'I', 'n', 's', 'e', 'r', 't', 0,
    'O', 'n', 'R', 'o', 'w', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    's', 'a', 'v', 'e', 'P', 'r', 'e', 'p', 'a', 'r', 'e', 0,
    's', 'e', 't', 'J', 'o', 'i', 'n', 'M', 'o', 'd', 'e', 0,
    's', 'e', 't', 'R', 'e', 'l', 'a', 't', 'i', 'o', 'n', 0,
    'i', 'n', 'd', 'e', 'x', 'C', 'o', 'l', 'u', 'm', 'n', 0,
    'c', 'l', 'e', 'a', 'r', 'V', 'a', 'l', 'u', 'e', 's', 0,
    'q', 'u', 'e', 'r', 'y', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    'b', 'o', 'u', 'n', 'd', 'V', 'a', 'l', 'u', 'e', 's', 0,
    'i', 's', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'd', 0,
    's', 'e', 't', 'R', 'e', 'q', 'u', 'i', 'r', 'e', 'd', 0,
    'i', 's', 'A', 'u', 't', 'o', 'V', 'a', 'l', 'u', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 'V', 'a', 'l', 'u', 'e', 0,
    't', 'r', 'i', 'm', 'S', 't', 'r', 'i', 'n', 'g', 's', 0,
    'F', 'i', 'n', 'i', 's', 'h', 'Q', 'u', 'e', 'r', 'y', 0,
    'a', 'd', 'd', 'D', 'a', 't', 'a', 'b', 'a', 's', 'e', 0,
    's', 'e', 't', 'H', 'o', 's', 't', 'N', 'a', 'm', 'e', 0,
    't', 'r', 'a', 'n', 's', 'a', 'c', 't', 'i', 'o', 'n', 0,
    'i', 's', 'O', 'p', 'e', 'n', 'E', 'r', 'r', 'o', 'r', 0,
    'b', 'u', 't', 't', 'o', 'n', '2', 'T', 'e', 'x', 't', 0,
    'b', 'u', 't', 't', 'o', 'n', '1', 'T', 'e', 'x', 't', 0,
    'd', 'r', 'a', 'w', 'D', 'i', 's', 'p', 'l', 'a', 'y', 0,
    's', 'e', 't', 'R', 'e', 'a', 'd', 'O', 'n', 'l', 'y', 0,
    'e', 'd', 'i', 't', 'o', 'r', 'E', 'v', 'e', 'n', 't', 0,
    's', 'e', 't', 'P', 'a', 's', 's', 'w', 'o', 'r', 'd', 0,
    's', 'e', 't', 'U', 's', 'e', 'r', 'N', 'a', 'm', 'e', 0,
    'c', 'u', 's', 't', 'o', 'm', 'E', 'v', 'e', 'n', 't', 0,
    'e', 'v', 'e', 'n', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'e', 'n', 'd', 'M', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'c', 'r', 'e', 'a', 't', 'e', 'I', 'n', 'd', 'e', 'x', 0,
    's', 'e', 't', 'I', 't', 'e', 'm', 'D', 'a', 't', 'a', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 'C', 'o', 'u', 'n', 't', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'S', 'q', 'l', 0,
    'f', 'i', 'e', 'l', 'd', 'I', 'n', 'd', 'e', 'x', 0,
    'p', 'r', 'i', 'm', 'a', 'r', 'y', 'K', 'e', 'y', 0,
    'f', 'e', 't', 'c', 'h', 'F', 'i', 'r', 's', 't', 0,
    'Q', 'S', 'q', 'l', 'R', 'e', 's', 'u', 'l', 't', 0,
    'n', 'e', 'x', 't', 'R', 'e', 's', 'u', 'l', 't', 0,
    'b', 'o', 'u', 'n', 'd', 'V', 'a', 'l', 'u', 'e', 0,
    'c', 'u', 'r', 's', 'o', 'r', 'N', 'a', 'm', 'e', 0,
    'Q', 'S', 'q', 'l', 'R', 'e', 'c', 'o', 'r', 'd', 0,
    's', 'e', 't', 'S', 'q', 'l', 'T', 'y', 'p', 'e', 0,
    'd', 'r', 'i', 'v', 'e', 'r', 'T', 'e', 'x', 't', 0,
    'Q', 'S', 'q', 'l', 'D', 'r', 'i', 'v', 'e', 'r', 0,
    'd', 'r', 'i', 'v', 'e', 'r', 'N', 'a', 'm', 'e', 0,
    'h', 'a', 's', 'F', 'e', 'a', 't', 'u', 'r', 'e', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 'S', 'p', 'a', 'n', 0,
    'c', 'o', 'n', 's', 't', 'r', 'a', 'i', 'n', 't', 0,
    'i', 's', 'R', 'e', 'a', 'd', 'O', 'n', 'l', 'y', 0,
    'r', 'e', 'p', 'e', 'a', 't', 'T', 'i', 'm', 'e', 0,
    'f', 'i', 'e', 'l', 'd', 'W', 'i', 'd', 't', 'h', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    'd', 'e', 'c', 'o', 'd', 'e', 'D', 'a', 't', 'a', 0,
    'e', 'n', 'c', 'o', 'd', 'e', 'D', 'a', 't', 'a', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'R', 'o', 'w', 's', 0,
    'i', 'n', 's', 'e', 'r', 't', 'R', 'o', 'w', 's', 0,
    'h', 'e', 'a', 'd', 'e', 'r', 'D', 'a', 't', 'a', 0,
    '_', '_', 'i', 'n', 'v', 'e', 'r', 't', '_', '_', 0,
    'r', 'e', 'v', 'e', 'r', 't', 'A', 'l', 'l', 0,
    's', 'u', 'b', 'm', 'i', 't', 'A', 'l', 'l', 0,
    's', 'e', 't', 'R', 'e', 'c', 'o', 'r', 'd', 0,
    'f', 'e', 't', 'c', 'h', 'L', 'a', 's', 't', 0,
    'f', 'e', 't', 'c', 'h', 'N', 'e', 'x', 't', 0,
    's', 'e', 't', 'S', 'e', 'l', 'e', 'c', 't', 0,
    'I', 'n', 'n', 'e', 'r', 'J', 'o', 'i', 'n', 0,
    'r', 'e', 'v', 'e', 'r', 't', 'R', 'o', 'w', 0,
    'b', 'i', 'n', 'd', 'V', 'a', 'l', 'u', 'e', 0,
    'e', 'x', 'e', 'c', 'B', 'a', 't', 'c', 'h', 0,
    'l', 'a', 's', 't', 'Q', 'u', 'e', 'r', 'y', 0,
    'Q', 'S', 'q', 'l', 'Q', 'u', 'e', 'r', 'y', 0,
    'Q', 'S', 'q', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    'f', 'i', 'e', 'l', 'd', 'N', 'a', 'm', 'e', 0,
    'Q', 'S', 'q', 'l', 'F', 'i', 'e', 'l', 'd', 0,
    's', 'e', 't', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'Q', 'S', 'q', 'l', 'E', 'r', 'r', 'o', 'r', 0,
    't', 'a', 'b', 'l', 'e', 'N', 'a', 'm', 'e', 0,
    'T', 'a', 'b', 'l', 'e', 'N', 'a', 'm', 'e', 0,
    'F', 'i', 'e', 'l', 'd', 'N', 'a', 'm', 'e', 0,
    'Q', 'u', 'e', 'r', 'y', 'S', 'i', 'z', 'e', 0,
    'l', 'a', 's', 't', 'E', 'r', 'r', 'o', 'r', 0,
    'A', 'l', 'l', 'T', 'a', 'b', 'l', 'e', 's', 0,
    'o', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'd', 'r', 'a', 'w', 'F', 'o', 'c', 'u', 's', 0,
    'd', 'r', 'a', 'w', 'C', 'h', 'e', 'c', 'k', 0,
    's', 'e', 't', 'A', 'c', 't', 'i', 'v', 'e', 0,
    'l', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'a', 'l', 'i', 'g', 'n', 'm', 'e', 'n', 't', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    's', 'e', 't', 'L', 'e', 'n', 'g', 't', 'h', 0,
    's', 'e', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'f', 'e', 't', 'c', 'h', 'M', 'o', 'r', 'e', 0,
    'm', 'i', 'm', 'e', 'T', 'y', 'p', 'e', 's', 0,
    'L', 'e', 'f', 't', 'J', 'o', 'i', 'n', 0,
    'r', 'e', 'l', 'a', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'T', 'a', 'b', 'l', 'e', 0,
    's', 'e', 't', 'Q', 'u', 'e', 'r', 'y', 0,
    'i', 's', 'S', 'e', 'l', 'e', 'c', 't', 0,
    'O', 'p', 't', 'i', 'o', 'n', 'a', 'l', 0,
    'd', 'a', 't', 'a', 'b', 'a', 's', 'e', 0,
    'h', 'o', 's', 't', 'N', 'a', 'm', 'e', 0,
    'r', 'o', 'l', 'l', 'b', 'a', 'c', 'k', 0,
    'f', 'i', 'l', 'l', 'R', 'u', 'l', 'e', 0,
    't', 'a', 'b', 'A', 'r', 'r', 'a', 'y', 0,
    't', 'a', 'b', 'S', 't', 'o', 'p', 's', 0,
    'u', 's', 'e', 'r', 'D', 'a', 't', 'a', 0,
    'p', 'r', 'e', 'v', 'i', 'o', 'u', 's', 0,
    's', 'i', 'z', 'e', 'H', 'i', 'n', 't', 0,
    's', 'h', 'o', 'r', 't', 'c', 'u', 't', 0,
    'r', 'e', 'l', 'a', 't', 'i', 'v', 'e', 0,
    'p', 'a', 's', 's', 'w', 'o', 'r', 'd', 0,
    'u', 's', 'e', 'r', 'N', 'a', 'm', 'e', 0,
    'b', 'e', 'h', 'a', 'v', 'i', 'o', 'r', 0,
    'p', 'o', 's', 'i', 't', 'i', 'o', 'n', 0,
    'f', 'i', 'l', 'l', 'C', 'h', 'a', 'r', 0,
    's', 'e', 't', 'V', 'a', 'l', 'u', 'e', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'c', 'o', 'n', 't', 'a', 'i', 'n', 's', 0,
    'i', 's', 'A', 'c', 't', 'i', 'v', 'e', 0,
    'm', 'i', 'm', 'e', 'D', 'a', 't', 'a', 0,
    'i', 't', 'e', 'm', 'D', 'a', 't', 'a', 0,
    'r', 'o', 'w', 'C', 'o', 'u', 'n', 't', 0,
    '_', '_', 'b', 'o', 'o', 'l', '_', '_', 0,
    '_', '_', 'i', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'a', 'n', 'd', '_', '_', 0,
    's', 'e', 't', 'S', 'o', 'r', 't', 0,
    'i', 's', 'D', 'i', 'r', 't', 'y', 0,
    's', 'e', 't', 'N', 'u', 'l', 'l', 0,
    's', 'e', 't', 'O', 'p', 'e', 'n', 0,
    'U', 'n', 'i', 'c', 'o', 'd', 'e', 0,
    'd', 'r', 'i', 'v', 'e', 'r', 's', 0,
    's', 'e', 't', 'N', 'a', 'm', 'e', 0,
    'U', 'n', 'k', 'n', 'o', 'w', 'n', 0,
    'p', 'r', 'e', 'p', 'a', 'r', 'e', 0,
    'e', 'x', 'p', 'o', 's', 'e', 'd', 0,
    'b', 'u', 't', 't', 'o', 'n', '2', 0,
    'b', 'u', 't', 't', 'o', 'n', '1', 0,
    'q', 'u', 'a', 'l', 'i', 't', 'y', 0,
    'y', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'x', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'r', 'o', 'w', 'S', 'p', 'a', 'n', 0,
    'c', 'a', 'p', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'P', 'o', 'r', 't', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    'N', 'o', 'E', 'r', 'r', 'o', 'r', 0,
    's', 'e', 't', 'T', 'y', 'p', 'e', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'r', 'e', 'p', 'l', 'a', 'c', 'e', 0,
    'i', 'n', 'd', 'e', 'x', 'O', 'f', 0,
    'i', 's', 'E', 'm', 'p', 't', 'y', 0,
    '_', '_', 'l', 'e', 'n', '_', '_', 0,
    's', 'e', 't', 'D', 'a', 't', 'a', 0,
    'i', 's', 'V', 'a', 'l', 'i', 'd', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    '_', '_', 'a', 'n', 'd', '_', '_', 0,
    '_', '_', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'n', 't', '_', '_', 0,
    '_', '_', 'i', 'o', 'r', '_', '_', 0,
    't', 'y', 'p', 'e', 'I', 'D', 0,
    'd', 'r', 'i', 'v', 'e', 'r', 0,
    'c', 'o', 'm', 'm', 'i', 't', 0,
    'r', 'e', 'c', 'o', 'r', 'd', 0,
    't', 'a', 'b', 'l', 'e', 's', 0,
    'B', 'i', 'n', 'a', 'r', 'y', 0,
    'f', 'i', 'n', 'i', 's', 'h', 0,
    'y', 'R', 'o', 'u', 'n', 'd', 0,
    'x', 'R', 'o', 'u', 'n', 'd', 0,
    's', 'e', 'l', 'e', 'c', 't', 0,
    'l', 'a', 'y', 'e', 'r', 's', 0,
    'w', 'i', 'n', 'd', 'o', 'w', 0,
    's', 'u', 'n', 'k', 'e', 'n', 0,
    'o', 'p', 't', 'i', 'o', 'n', 0,
    'w', 'i', 'd', 'g', 'e', 't', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 0,
    's', 'e', 'n', 'd', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', '9', 0,
    'v', 'a', 'l', 'u', 'e', '8', 0,
    'v', 'a', 'l', 'u', 'e', '7', 0,
    'v', 'a', 'l', 'u', 'e', '6', 0,
    'v', 'a', 'l', 'u', 'e', '5', 0,
    'v', 'a', 'l', 'u', 'e', '4', 0,
    'v', 'a', 'l', 'u', 'e', '3', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 's', 't', 'e', 'm', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    'i', 's', 'O', 'p', 'e', 'n', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'n', 'u', 'm', 'b', 'e', 'r', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'i', 'n', 's', 'e', 'r', 't', 0,
    'a', 'p', 'p', 'e', 'n', 'd', 0,
    'l', 'e', 'n', 'g', 't', 'h', 0,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'i', 's', 'N', 'u', 'l', 'l', 0,
    'r', 'e', 's', 'u', 'l', 't', 0,
    'r', 'e', 'v', 'e', 'r', 't', 0,
    's', 'u', 'b', 'm', 'i', 't', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 0,
    'o', 'f', 'f', 's', 'e', 't', 0,
    'h', 'a', 'n', 'd', 'l', 'e', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 0,
    'f', 'i', 'l', 't', 'e', 'r', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    '_', '_', 'n', 'e', '_', '_', 0,
    '_', '_', 'e', 'q', '_', '_', 0,
    '_', '_', 'o', 'r', '_', '_', 0,
    'f', 'e', 't', 'c', 'h', 0,
    's', 'e', 't', 'A', 't', 0,
    'V', 'i', 'e', 'w', 's', 0,
    'I', 'n', 'O', 'u', 't', 0,
    'f', 'i', 'e', 'l', 'd', 0,
    'b', 'r', 'u', 's', 'h', 0,
    'p', 'a', 'i', 'n', 't', 0,
    'q', 'u', 'e', 'r', 'y', 0,
    'h', 'i', 'n', 't', 's', 0,
    'e', 'x', 'e', 'c', '_', 0,
    'c', 'l', 'e', 'a', 'r', 0,
    'r', 'e', 's', 'e', 't', 0,
    'f', 'i', 'r', 's', 't', 0,
    'm', 'a', 't', 'c', 'h', 0,
    'b', 'u', 'd', 'd', 'y', 0,
    'c', 'o', 'u', 'n', 't', 0,
    'v', 'a', 'l', 'u', 'e', 0,
    'i', 'n', 'd', 'e', 'x', 0,
    'c', 'l', 'o', 's', 'e', 0,
    'f', 'l', 'a', 'g', 's', 0,
    'e', 'v', 'e', 'n', 't', 0,
    'm', 's', 'e', 'c', 's', 0,
    's', 't', 'a', 't', 'e', 0,
    'B', 'L', 'O', 'B', 0,
    'u', 's', 'e', 'r', 0,
    'Q', 'S', 'q', 'l', 0,
    'p', 'o', 'r', 't', 0,
    'h', 'o', 's', 't', 0,
    't', 'e', 'x', 't', 0,
    'm', 'o', 'd', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'e', 'x', 'e', 'c', 0,
    'f', 'i', 'l', 'l', 0,
    'f', 'r', 'o', 'm', 0,
    'l', 'a', 's', 't', 0,
    's', 'p', 'a', 'n', 0,
    's', 'o', 'r', 't', 0,
    'r', 'o', 'l', 'e', 0,
    'n', 'e', 'x', 't', 0,
    'd', 'a', 't', 'a', 0,
    't', 'y', 'p', 'e', 0,
    's', 'e', 'e', 'k', 0,
    's', 'i', 'z', 'e', 0,
    'o', 'p', 'e', 'n', 0,
    'p', 'o', 's', 0,
    'd', 'b', 0,
    'I', 'n', 0,
    's', 'w', 0,
    's', 'y', 0,
    's', 'x', 0,
};
#line 24 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 519 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

bool sipVH_QtSql_0(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QSqlRecord& a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QSqlRecord(a0),sipType_QSqlRecord,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

bool sipVH_QtSql_1(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0,const QSqlRecord& a1)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "iN",a0,new QSqlRecord(a1),sipType_QSqlRecord,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

void sipVH_QtSql_2(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QSqlTableModel::EditStrategy a0)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "F",a0,sipType_QSqlTableModel_EditStrategy);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

QVariant sipVH_QtSql_3(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QVariant sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVariant, &sipRes);

    return sipRes;
}

QSqlRecord sipVH_QtSql_4(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QSqlRecord sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QSqlRecord, &sipRes);

    return sipRes;
}

void sipVH_QtSql_5(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QString& a0,const QVariant& a1,QSql::ParamType a2)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NNN",new QString(a0),sipType_QString,NULL,new QVariant(a1),sipType_QVariant,NULL,new QSql::ParamType(a2),sipType_QSql_ParamType,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

void sipVH_QtSql_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0,const QVariant& a1,QSql::ParamType a2)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "iNN",a0,new QVariant(a1),sipType_QVariant,NULL,new QSql::ParamType(a2),sipType_QSql_ParamType,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

void sipVH_QtSql_7(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QSqlError& a0)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QSqlError(a0),sipType_QSqlError,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

QSqlTableModel* sipVH_QtSql_8(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0)
{
    QSqlTableModel* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "i",a0);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H0", sipType_QSqlTableModel, &sipRes);

    return sipRes;
}

void sipVH_QtSql_9(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0,const QSqlRelation& a1)
{
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "iN",a0,new QSqlRelation(a1),sipType_QSqlRelation,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "Z");
}

bool sipVH_QtSql_10(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QString& a0,const QString& a1,const QString& a2,const QString& a3,int a4,const QString& a5)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NNNNiN",new QString(a0),sipType_QString,NULL,new QString(a1),sipType_QString,NULL,new QString(a2),sipType_QString,NULL,new QString(a3),sipType_QString,NULL,a4,new QString(a5),sipType_QString,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

QSqlResult* sipVH_QtSql_11(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QSqlResult* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H2", sipType_QSqlResult, &sipRes);

    return sipRes;
}

bool sipVH_QtSql_12(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QSqlDriver::DriverFeature a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "F",a0,sipType_QSqlDriver_DriverFeature);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

QString sipVH_QtSql_13(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QSqlDriver::StatementType a0,const QString& a1,const QSqlRecord& a2,bool a3)
{
    QString sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "FNNb",a0,sipType_QSqlDriver_StatementType,new QString(a1),sipType_QString,NULL,new QSqlRecord(a2),sipType_QSqlRecord,NULL,a3);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QString, &sipRes);

    return sipRes;
}

QString sipVH_QtSql_14(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QString& a0,QSqlDriver::IdentifierType a1)
{
    QString sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "NF",new QString(a0),sipType_QString,NULL,a1,sipType_QSqlDriver_IdentifierType);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QString, &sipRes);

    return sipRes;
}

QString sipVH_QtSql_15(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QSqlField& a0,bool a1)
{
    QString sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "Nb",new QSqlField(a0),sipType_QSqlField,NULL,a1);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QString, &sipRes);

    return sipRes;
}

QSqlRecord sipVH_QtSql_16(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QString& a0)
{
    QSqlRecord sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QString(a0),sipType_QString,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QSqlRecord, &sipRes);

    return sipRes;
}

QSqlIndex sipVH_QtSql_17(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const QString& a0)
{
    QSqlIndex sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "N",new QString(a0),sipType_QString,NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QSqlIndex, &sipRes);

    return sipRes;
}

QStringList sipVH_QtSql_18(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, QSql::TableType a0)
{
    QStringList sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "F",a0,sipType_QSql_TableType);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QStringList, &sipRes);

    return sipRes;
}

QSqlDriver* sipVH_QtSql_19(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    QSqlDriver* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H2", sipType_QSqlDriver, &sipRes);

    return sipRes;
}


/* Convert to a sub-class if possible. */
extern "C" {static const sipTypeDef *sipSubClass_QSqlDriver(void **);}
static const sipTypeDef *sipSubClass_QSqlDriver(void **sipCppRet)
{
    QObject *sipCpp = reinterpret_cast<QObject *>(*sipCppRet);
    const sipTypeDef *sipType;

#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldriver.sip"
    static struct class_graph {
            const char *name;
            sipTypeDef **type;
            int yes, no;
        } graph[] = {
            {sipName_QSqlQueryModel,	&sipType_QSqlQueryModel,	3, 1},
            {sipName_QSqlRelationalDelegate,	&sipType_QSqlRelationalDelegate,	-1, 2},
            {sipName_QSqlDriver,	&sipType_QSqlDriver,	-1, -1},
            {sipName_QSqlTableModel,	&sipType_QSqlTableModel,	4, -1},
            {sipName_QSqlRelationalTableModel,	&sipType_QSqlRelationalTableModel,	-1, -1},
        };
    
        int i = 0;
    
        sipType = 0;
    
        do
        {
            struct class_graph *cg = &graph[i];
    
            if (cg->name != NULL && sipCpp->inherits(cg->name))
            {
                sipType = *cg->type;
                i = cg->yes;
            }
            else
                i = cg->no;
        }
        while (i >= 0);
#line 744 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

    return sipType;
}


extern "C" {static PyObject *slot_QSql_ParamTypeFlag___or__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamTypeFlag___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::ParamTypeFlag a0;
        QSql::ParamType* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QSql_ParamTypeFlag, &a0, sipType_QSql_ParamType, &a1, &a1State))
        {
            QSql::ParamType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSql::ParamType((a0 | *a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a1,sipType_QSql_ParamType,a1State);

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QSql_ParamTypeFlag[] = {
    {(void *)slot_QSql_ParamTypeFlag___or__, or_slot},
    {0, (sipPySlotType)0}
};

static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlTableModel__EditStrategy, {0}}, sipNameNr_EditStrategy, 27, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlResult__BindingSyntax, {0}}, sipNameNr_BindingSyntax, 25, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlRelationalTableModel__JoinMode, {0}}, sipNameNr_JoinMode, 23, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlQuery__BatchExecutionMode, {0}}, sipNameNr_BatchExecutionMode, 17, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlField__RequiredStatus, {0}}, sipNameNr_RequiredStatus, 14, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlError__ErrorType, {0}}, sipNameNr_ErrorType, 12, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlDriver__IdentifierType, {0}}, sipNameNr_IdentifierType, 7, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlDriver__StatementType, {0}}, sipNameNr_StatementType, 7, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSqlDriver__DriverFeature, {0}}, sipNameNr_DriverFeature, 7, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSql__NumericalPrecisionPolicy, {0}}, sipNameNr_NumericalPrecisionPolicy, 0, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSql__TableType, {0}}, sipNameNr_TableType, 0, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSql__ParamTypeFlag, {0}}, sipNameNr_ParamTypeFlag, 0, slots_QSql_ParamTypeFlag},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QSql__Location, {0}}, sipNameNr_Location, 0, NULL},
};


/*
 * This defines each type in this module.
 */
static sipTypeDef *typesTable[] = {
    &sipTypeDef_QtSql_QSql.super.ctd_base,
    &enumTypes[12].etd_base,
    &enumTypes[9].etd_base,
    &sipTypeDef_QtSql_QSql_ParamType.super.ctd_base,
    &enumTypes[11].etd_base,
    &enumTypes[10].etd_base,
    &sipTypeDef_QtSql_QSqlDatabase.super.ctd_base,
    &sipTypeDef_QtSql_QSqlDriver.super.ctd_base,
    &enumTypes[8].etd_base,
    &enumTypes[6].etd_base,
    &enumTypes[7].etd_base,
    &sipTypeDef_QtSql_QSqlDriverCreatorBase.super.ctd_base,
    &sipTypeDef_QtSql_QSqlError.super.ctd_base,
    &enumTypes[5].etd_base,
    &sipTypeDef_QtSql_QSqlField.super.ctd_base,
    &enumTypes[4].etd_base,
    &sipTypeDef_QtSql_QSqlIndex.super.ctd_base,
    &sipTypeDef_QtSql_QSqlQuery.super.ctd_base,
    &enumTypes[3].etd_base,
    &sipTypeDef_QtSql_QSqlQueryModel.super.ctd_base,
    &sipTypeDef_QtSql_QSqlRecord.super.ctd_base,
    &sipTypeDef_QtSql_QSqlRelation.super.ctd_base,
    &sipTypeDef_QtSql_QSqlRelationalDelegate.super.ctd_base,
    &sipTypeDef_QtSql_QSqlRelationalTableModel.super.ctd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtSql_QSqlResult.super.ctd_base,
    &enumTypes[1].etd_base,
    &sipTypeDef_QtSql_QSqlTableModel.super.ctd_base,
    &enumTypes[0].etd_base,
    &sipTypeDef_QtSql_QVector_0100QVariant.mtd_base,
};


/*
 * This defines the virtual handlers that this module implements and can be
 * used by other modules.
 */
static sipVirtHandlerFunc virtHandlersTable[] = {
    (sipVirtHandlerFunc)sipVH_QtSql_0,
    (sipVirtHandlerFunc)sipVH_QtSql_1,
    (sipVirtHandlerFunc)sipVH_QtSql_2,
    (sipVirtHandlerFunc)sipVH_QtSql_3,
    (sipVirtHandlerFunc)sipVH_QtSql_4,
    (sipVirtHandlerFunc)sipVH_QtSql_5,
    (sipVirtHandlerFunc)sipVH_QtSql_6,
    (sipVirtHandlerFunc)sipVH_QtSql_7,
    (sipVirtHandlerFunc)sipVH_QtSql_8,
    (sipVirtHandlerFunc)sipVH_QtSql_9,
    (sipVirtHandlerFunc)sipVH_QtSql_10,
    (sipVirtHandlerFunc)sipVH_QtSql_11,
    (sipVirtHandlerFunc)sipVH_QtSql_12,
    (sipVirtHandlerFunc)sipVH_QtSql_13,
    (sipVirtHandlerFunc)sipVH_QtSql_14,
    (sipVirtHandlerFunc)sipVH_QtSql_15,
    (sipVirtHandlerFunc)sipVH_QtSql_16,
    (sipVirtHandlerFunc)sipVH_QtSql_17,
    (sipVirtHandlerFunc)sipVH_QtSql_18,
    (sipVirtHandlerFunc)sipVH_QtSql_19,
};


/* This defines the modules that this module needs to import. */
static sipImportedModuleDef importsTable[] = {
    {"PyQt4.QtCore", 1, NULL},
    {"PyQt4.QtGui", -1, NULL},
    {NULL, -1, NULL}
};


/* This defines the class sub-convertors that this module defines. */
static sipSubClassConvertorDef convertorsTable[] = {
    {sipSubClass_QSqlDriver, {141, 0, 0}, NULL},
    {NULL, {0, 0, 0}, NULL}
};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtSql = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt4_QtSql,
    0,
    -1,
    sipStrings_QtSql,
    importsTable,
    NULL,
    30,
    typesTable,
    NULL,
    0,
    NULL,
    0,
    NULL,
    virtHandlersTable,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI_QtSql;
const sipExportedModuleDef *sipModuleAPI_QtSql_QtCore;
const sipExportedModuleDef *sipModuleAPI_QtSql_QtGui;

sip_qt_metaobject_func sip_QtSql_qt_metaobject;
sip_qt_metacall_func sip_QtSql_qt_metacall;
sip_qt_metacast_func sip_QtSql_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtSql
#define SIP_MODULE_TYPE         PyObject *
#define SIP_MODULE_DISCARD(r)   Py_DECREF(r)
#define SIP_MODULE_RETURN(r)    return (r)
#else
#define SIP_MODULE_ENTRY        initQtSql
#define SIP_MODULE_TYPE         void
#define SIP_MODULE_DISCARD(r)
#define SIP_MODULE_RETURN(r)    return
#endif

#if defined(SIP_STATIC_MODULE)
extern "C" SIP_MODULE_TYPE SIP_MODULE_ENTRY()
#else
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
    static PyMethodDef sip_methods[] = {
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt4.QtSql",
        NULL,
        -1,
        sip_methods,
        NULL,
        NULL,
        NULL,
        NULL
    };
#endif

    PyObject *sipModule, *sipModuleDict;
    PyObject *sip_sipmod, *sip_capiobj;

    /* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
    sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
    sipModule = Py_InitModule(sipName_PyQt4_QtSql, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt4_QtSql), sip_methods);
#endif

    if (sipModule == NULL)
        SIP_MODULE_RETURN(NULL);

    sipModuleDict = PyModule_GetDict(sipModule);

    /* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
    sip_sipmod = PyImport_ImportModule(SIP_MODULE_NAME);
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#endif

    if (sip_sipmod == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

    sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
    Py_DECREF(sip_sipmod);

#if defined(SIP_USE_PYCAPSULE)
    if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
    if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

#if defined(SIP_USE_PYCAPSULE)
    sipAPI_QtSql = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI_QtSql = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

#if defined(SIP_USE_PYCAPSULE)
    if (sipAPI_QtSql == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }
#endif

    /* Export the module and publish it's API. */
    if (sipExportModule(&sipModuleAPI_QtSql,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    sip_QtSql_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtSql_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtSql_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

    if (!sip_QtSql_qt_metacast)
        Py_FatalError("Unable to import qtcore_qt_metacast");

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_QtSql,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    /* Get the APIs of the modules that this one is dependent on. */
    sipModuleAPI_QtSql_QtCore = sipModuleAPI_QtSql.em_imports[0].im_module;
    sipModuleAPI_QtSql_QtGui = sipModuleAPI_QtSql.em_imports[1].im_module;

    SIP_MODULE_RETURN(sipModule);
}

#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 1050 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1054 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1057 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


extern "C" {static void assign_QVector_0100QVariant(void *, SIP_SSIZE_T, const void *);}
static void assign_QVector_0100QVariant(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QVector<QVariant> *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QVector<QVariant> *>(sipSrc);
}


extern "C" {static void *array_QVector_0100QVariant(SIP_SSIZE_T);}
static void *array_QVector_0100QVariant(SIP_SSIZE_T sipNrElem)
{
    return new QVector<QVariant>[sipNrElem];
}


extern "C" {static void *copy_QVector_0100QVariant(const void *, SIP_SSIZE_T);}
static void *copy_QVector_0100QVariant(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QVector<QVariant>(reinterpret_cast<const QVector<QVariant> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QVector_0100QVariant(void *, int);}
static void release_QVector_0100QVariant(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast<QVector<QVariant> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QVector_0100QVariant(PyObject *, void **, int *, PyObject *);}
static int convertTo_QVector_0100QVariant(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QVector<QVariant> **sipCppPtr = reinterpret_cast<QVector<QVariant> **>(sipCppPtrV);

#line 59 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvector.sip"
    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PyList_Check(sipPy))
            return 0;

        for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
            if (!sipCanConvertToType(PyList_GET_ITEM(sipPy, i), sipType_QVariant, SIP_NOT_NONE))
                return 0;

        return 1;
    }

    QVector<QVariant> *qv = new QVector<QVariant>;
 
    for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(sipPy); ++i)
    {
        int state;
        QVariant *t = reinterpret_cast<QVariant *>(sipConvertToType(PyList_GET_ITEM(sipPy, i), sipType_QVariant, sipTransferObj, SIP_NOT_NONE, &state, sipIsErr));
 
        if (*sipIsErr)
        {
            sipReleaseType(t, sipType_QVariant, state);

            delete qv;
            return 0;
        }

        qv->append(*t);

        sipReleaseType(t, sipType_QVariant, state);
    }
 
    *sipCppPtr = qv;
 
    return sipGetState(sipTransferObj);
#line 1134 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QVector_0100QVariant(void *, PyObject *);}
static PyObject *convertFrom_QVector_0100QVariant(void *sipCppV, PyObject *sipTransferObj)
{
   QVector<QVariant> *sipCpp = reinterpret_cast<QVector<QVariant> *>(sipCppV);

#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvector.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QVariant *t = new QVariant(sipCpp->at(i));
        PyObject *tobj;

        if ((tobj = sipConvertFromNewType(t, sipType_QVariant, sipTransferObj)) == NULL)
        {
            Py_DECREF(l);
            delete t;

            return NULL;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 1168 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtSql_QVector_0100QVariant = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_1076,
        {0}
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QVector_0100QVariant,
    array_QVector_0100QVariant,
    copy_QVector_0100QVariant,
    release_QVector_0100QVariant,
    convertTo_QVector_0100QVariant,
    convertFrom_QVector_0100QVariant
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlresult.sip"
#include <qsqlresult.h>
#line 1199 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldriver.sip"
#include <qsqldriver.h>
#line 1203 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1206 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 1209 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 1212 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvector.sip"
#include <qvector.h>
#line 1215 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1218 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 1221 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 1224 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlResult : public QSqlResult
{
public:
    sipQSqlResult(const QSqlDriver*);
    virtual ~sipQSqlResult();

    /* Expose this protected enum. */
    enum sipBindingSyntax {
        PositionalBinding = QSqlResult::PositionalBinding,
        NamedBinding = QSqlResult::NamedBinding
    };

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    int sipProtect_at() const;
    QString sipProtect_lastQuery() const;
    QSqlError sipProtect_lastError() const;
    bool sipProtect_isValid() const;
    bool sipProtect_isActive() const;
    bool sipProtect_isSelect() const;
    bool sipProtect_isForwardOnly() const;
    const QSqlDriver* sipProtect_driver() const;
    void sipProtectVirt_setAt(bool,int);
    void sipProtectVirt_setActive(bool,bool);
    void sipProtectVirt_setLastError(bool,const QSqlError&);
    void sipProtectVirt_setQuery(bool,const QString&);
    void sipProtectVirt_setSelect(bool,bool);
    void sipProtectVirt_setForwardOnly(bool,bool);
    bool sipProtectVirt_exec(bool);
    bool sipProtectVirt_prepare(bool,const QString&);
    bool sipProtectVirt_savePrepare(bool,const QString&);
    void sipProtectVirt_bindValue(bool,int,const QVariant&,QSql::ParamType);
    void sipProtectVirt_bindValue(bool,const QString&,const QVariant&,QSql::ParamType);
    void sipProtect_addBindValue(const QVariant&,QSql::ParamType);
    QVariant sipProtect_boundValue(const QString&) const;
    QVariant sipProtect_boundValue(int) const;
    QSql::ParamType sipProtect_bindValueType(const QString&) const;
    QSql::ParamType sipProtect_bindValueType(int) const;
    int sipProtect_boundValueCount() const;
    QVector<QVariant>& sipProtect_boundValues() const;
    QString sipProtect_executedQuery() const;
    QString sipProtect_boundValueName(int) const;
    void sipProtect_clear();
    bool sipProtect_hasOutValues() const;
    int sipProtect_bindingSyntax() const;
    QVariant sipProtect_data(int);
    bool sipProtect_isNull(int);
    bool sipProtect_reset(const QString&);
    bool sipProtect_fetch(int);
    bool sipProtectVirt_fetchNext(bool);
    bool sipProtectVirt_fetchPrevious(bool);
    bool sipProtect_fetchFirst();
    bool sipProtect_fetchLast();
    int sipProtect_size();
    int sipProtect_numRowsAffected();
    QSqlRecord sipProtectVirt_record(bool) const;
    QVariant sipProtectVirt_lastInsertId(bool) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    QVariant lastInsertId() const;
    QSqlRecord record() const;
    int numRowsAffected();
    int size();
    bool fetchLast();
    bool fetchFirst();
    bool fetchPrevious();
    bool fetchNext();
    bool fetch(int);
    bool reset(const QString&);
    bool isNull(int);
    QVariant data(int);
    void bindValue(const QString&,const QVariant&,QSql::ParamType);
    void bindValue(int,const QVariant&,QSql::ParamType);
    bool savePrepare(const QString&);
    bool prepare(const QString&);
    bool exec();
    void setForwardOnly(bool);
    void setSelect(bool);
    void setQuery(const QString&);
    void setLastError(const QSqlError&);
    void setActive(bool);
    void setAt(int);
    QVariant handle() const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlResult(const sipQSqlResult &);
    sipQSqlResult &operator = (const sipQSqlResult &);

    char sipPyMethods[25];
};

sipQSqlResult::sipQSqlResult(const QSqlDriver*a0): QSqlResult(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlResult::~sipQSqlResult()
{
    sipCommonDtor(sipPySelf);
}

QVariant sipQSqlResult::lastInsertId() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,NULL,sipName_lastInsertId);

    if (!sipMeth)
        return QSqlResult::lastInsertId();

    extern QVariant sipVH_QtSql_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSql_3(sipGILState, 0, sipPySelf, sipMeth);
}

QSqlRecord sipQSqlResult::record() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[1]),sipPySelf,NULL,sipName_record);

    if (!sipMeth)
        return QSqlResult::record();

    extern QSqlRecord sipVH_QtSql_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSql_4(sipGILState, 0, sipPySelf, sipMeth);
}

int sipQSqlResult::numRowsAffected()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,sipName_QSqlResult,sipName_numRowsAffected);

    if (!sipMeth)
        return 0;

    typedef int (*sipVH_QtCore_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_6)(sipModuleAPI_QtSql_QtCore->em_virthandlers[6]))(sipGILState, 0, sipPySelf, sipMeth);
}

int sipQSqlResult::size()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,sipName_QSqlResult,sipName_size);

    if (!sipMeth)
        return 0;

    typedef int (*sipVH_QtCore_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_6)(sipModuleAPI_QtSql_QtCore->em_virthandlers[6]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlResult::fetchLast()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,sipName_QSqlResult,sipName_fetchLast);

    if (!sipMeth)
        return 0;

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlResult::fetchFirst()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,sipName_QSqlResult,sipName_fetchFirst);

    if (!sipMeth)
        return 0;

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlResult::fetchPrevious()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_fetchPrevious);

    if (!sipMeth)
        return QSqlResult::fetchPrevious();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlResult::fetchNext()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_fetchNext);

    if (!sipMeth)
        return QSqlResult::fetchNext();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlResult::fetch(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,sipName_QSqlResult,sipName_fetch);

    if (!sipMeth)
        return 0;

    typedef bool (*sipVH_QtCore_23)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return ((sipVH_QtCore_23)(sipModuleAPI_QtSql_QtCore->em_virthandlers[23]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlResult::reset(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,sipName_QSqlResult,sipName_reset);

    if (!sipMeth)
        return 0;

    typedef bool (*sipVH_QtCore_28)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    return ((sipVH_QtCore_28)(sipModuleAPI_QtSql_QtCore->em_virthandlers[28]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlResult::isNull(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,sipName_QSqlResult,sipName_isNull);

    if (!sipMeth)
        return 0;

    typedef bool (*sipVH_QtCore_23)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return ((sipVH_QtCore_23)(sipModuleAPI_QtSql_QtCore->em_virthandlers[23]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVariant sipQSqlResult::data(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,sipName_QSqlResult,sipName_data);

    if (!sipMeth)
        return QVariant();

    typedef QVariant (*sipVH_QtGui_69)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return ((sipVH_QtGui_69)(sipModuleAPI_QtSql_QtGui->em_virthandlers[69]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlResult::bindValue(const QString& a0,const QVariant& a1,QSql::ParamType a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,NULL,sipName_bindValue);

    if (!sipMeth)
    {
        QSqlResult::bindValue(a0,a1,a2);
        return;
    }

    extern void sipVH_QtSql_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&,const QVariant&,QSql::ParamType);

    sipVH_QtSql_5(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlResult::bindValue(int a0,const QVariant& a1,QSql::ParamType a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[13],sipPySelf,NULL,sipName_bindValue);

    if (!sipMeth)
    {
        QSqlResult::bindValue(a0,a1,a2);
        return;
    }

    extern void sipVH_QtSql_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,const QVariant&,QSql::ParamType);

    sipVH_QtSql_6(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlResult::savePrepare(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[14],sipPySelf,NULL,sipName_savePrepare);

    if (!sipMeth)
        return QSqlResult::savePrepare(a0);

    typedef bool (*sipVH_QtCore_28)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    return ((sipVH_QtCore_28)(sipModuleAPI_QtSql_QtCore->em_virthandlers[28]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlResult::prepare(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,NULL,sipName_prepare);

    if (!sipMeth)
        return QSqlResult::prepare(a0);

    typedef bool (*sipVH_QtCore_28)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    return ((sipVH_QtCore_28)(sipModuleAPI_QtSql_QtCore->em_virthandlers[28]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlResult::exec()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[16],sipPySelf,NULL,sipName_exec);

    if (!sipMeth)
        return QSqlResult::exec();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQSqlResult::setForwardOnly(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[17],sipPySelf,NULL,sipName_setForwardOnly);

    if (!sipMeth)
    {
        QSqlResult::setForwardOnly(a0);
        return;
    }

    typedef void (*sipVH_QtGui_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    ((sipVH_QtGui_6)(sipModuleAPI_QtSql_QtGui->em_virthandlers[6]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlResult::setSelect(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[18],sipPySelf,NULL,sipName_setSelect);

    if (!sipMeth)
    {
        QSqlResult::setSelect(a0);
        return;
    }

    typedef void (*sipVH_QtGui_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    ((sipVH_QtGui_6)(sipModuleAPI_QtSql_QtGui->em_virthandlers[6]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlResult::setQuery(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[19],sipPySelf,NULL,sipName_setQuery);

    if (!sipMeth)
    {
        QSqlResult::setQuery(a0);
        return;
    }

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtSql_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlResult::setLastError(const QSqlError& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[20],sipPySelf,NULL,sipName_setLastError);

    if (!sipMeth)
    {
        QSqlResult::setLastError(a0);
        return;
    }

    extern void sipVH_QtSql_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QSqlError&);

    sipVH_QtSql_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlResult::setActive(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,NULL,sipName_setActive);

    if (!sipMeth)
    {
        QSqlResult::setActive(a0);
        return;
    }

    typedef void (*sipVH_QtGui_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    ((sipVH_QtGui_6)(sipModuleAPI_QtSql_QtGui->em_virthandlers[6]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlResult::setAt(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[22],sipPySelf,NULL,sipName_setAt);

    if (!sipMeth)
    {
        QSqlResult::setAt(a0);
        return;
    }

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtSql_QtCore->em_virthandlers[4]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVariant sipQSqlResult::handle() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[23]),sipPySelf,NULL,sipName_handle);

    if (!sipMeth)
        return QSqlResult::handle();

    extern QVariant sipVH_QtSql_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSql_3(sipGILState, 0, sipPySelf, sipMeth);
}

int sipQSqlResult::sipProtect_at() const
{
    return QSqlResult::at();
}

QString sipQSqlResult::sipProtect_lastQuery() const
{
    return QSqlResult::lastQuery();
}

QSqlError sipQSqlResult::sipProtect_lastError() const
{
    return QSqlResult::lastError();
}

bool sipQSqlResult::sipProtect_isValid() const
{
    return QSqlResult::isValid();
}

bool sipQSqlResult::sipProtect_isActive() const
{
    return QSqlResult::isActive();
}

bool sipQSqlResult::sipProtect_isSelect() const
{
    return QSqlResult::isSelect();
}

bool sipQSqlResult::sipProtect_isForwardOnly() const
{
    return QSqlResult::isForwardOnly();
}

const QSqlDriver* sipQSqlResult::sipProtect_driver() const
{
    return QSqlResult::driver();
}

void sipQSqlResult::sipProtectVirt_setAt(bool sipSelfWasArg,int a0)
{
    (sipSelfWasArg ? QSqlResult::setAt(a0) : setAt(a0));
}

void sipQSqlResult::sipProtectVirt_setActive(bool sipSelfWasArg,bool a0)
{
    (sipSelfWasArg ? QSqlResult::setActive(a0) : setActive(a0));
}

void sipQSqlResult::sipProtectVirt_setLastError(bool sipSelfWasArg,const QSqlError& a0)
{
    (sipSelfWasArg ? QSqlResult::setLastError(a0) : setLastError(a0));
}

void sipQSqlResult::sipProtectVirt_setQuery(bool sipSelfWasArg,const QString& a0)
{
    (sipSelfWasArg ? QSqlResult::setQuery(a0) : setQuery(a0));
}

void sipQSqlResult::sipProtectVirt_setSelect(bool sipSelfWasArg,bool a0)
{
    (sipSelfWasArg ? QSqlResult::setSelect(a0) : setSelect(a0));
}

void sipQSqlResult::sipProtectVirt_setForwardOnly(bool sipSelfWasArg,bool a0)
{
    (sipSelfWasArg ? QSqlResult::setForwardOnly(a0) : setForwardOnly(a0));
}

bool sipQSqlResult::sipProtectVirt_exec(bool sipSelfWasArg)
{
    return (sipSelfWasArg ? QSqlResult::exec() : exec());
}

bool sipQSqlResult::sipProtectVirt_prepare(bool sipSelfWasArg,const QString& a0)
{
    return (sipSelfWasArg ? QSqlResult::prepare(a0) : prepare(a0));
}

bool sipQSqlResult::sipProtectVirt_savePrepare(bool sipSelfWasArg,const QString& a0)
{
    return (sipSelfWasArg ? QSqlResult::savePrepare(a0) : savePrepare(a0));
}

void sipQSqlResult::sipProtectVirt_bindValue(bool sipSelfWasArg,int a0,const QVariant& a1,QSql::ParamType a2)
{
    (sipSelfWasArg ? QSqlResult::bindValue(a0,a1,a2) : bindValue(a0,a1,a2));
}

void sipQSqlResult::sipProtectVirt_bindValue(bool sipSelfWasArg,const QString& a0,const QVariant& a1,QSql::ParamType a2)
{
    (sipSelfWasArg ? QSqlResult::bindValue(a0,a1,a2) : bindValue(a0,a1,a2));
}

void sipQSqlResult::sipProtect_addBindValue(const QVariant& a0,QSql::ParamType a1)
{
    QSqlResult::addBindValue(a0,a1);
}

QVariant sipQSqlResult::sipProtect_boundValue(const QString& a0) const
{
    return QSqlResult::boundValue(a0);
}

QVariant sipQSqlResult::sipProtect_boundValue(int a0) const
{
    return QSqlResult::boundValue(a0);
}

QSql::ParamType sipQSqlResult::sipProtect_bindValueType(const QString& a0) const
{
    return QSqlResult::bindValueType(a0);
}

QSql::ParamType sipQSqlResult::sipProtect_bindValueType(int a0) const
{
    return QSqlResult::bindValueType(a0);
}

int sipQSqlResult::sipProtect_boundValueCount() const
{
    return QSqlResult::boundValueCount();
}

QVector<QVariant>& sipQSqlResult::sipProtect_boundValues() const
{
    return QSqlResult::boundValues();
}

QString sipQSqlResult::sipProtect_executedQuery() const
{
    return QSqlResult::executedQuery();
}

QString sipQSqlResult::sipProtect_boundValueName(int a0) const
{
    return QSqlResult::boundValueName(a0);
}

void sipQSqlResult::sipProtect_clear()
{
    QSqlResult::clear();
}

bool sipQSqlResult::sipProtect_hasOutValues() const
{
    return QSqlResult::hasOutValues();
}

int sipQSqlResult::sipProtect_bindingSyntax() const
{
    return (int)QSqlResult::bindingSyntax();
}

QVariant sipQSqlResult::sipProtect_data(int a0)
{
    return data(a0);
}

bool sipQSqlResult::sipProtect_isNull(int a0)
{
    return isNull(a0);
}

bool sipQSqlResult::sipProtect_reset(const QString& a0)
{
    return reset(a0);
}

bool sipQSqlResult::sipProtect_fetch(int a0)
{
    return fetch(a0);
}

bool sipQSqlResult::sipProtectVirt_fetchNext(bool sipSelfWasArg)
{
    return (sipSelfWasArg ? QSqlResult::fetchNext() : fetchNext());
}

bool sipQSqlResult::sipProtectVirt_fetchPrevious(bool sipSelfWasArg)
{
    return (sipSelfWasArg ? QSqlResult::fetchPrevious() : fetchPrevious());
}

bool sipQSqlResult::sipProtect_fetchFirst()
{
    return fetchFirst();
}

bool sipQSqlResult::sipProtect_fetchLast()
{
    return fetchLast();
}

int sipQSqlResult::sipProtect_size()
{
    return size();
}

int sipQSqlResult::sipProtect_numRowsAffected()
{
    return numRowsAffected();
}

QSqlRecord sipQSqlResult::sipProtectVirt_record(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? QSqlResult::record() : record());
}

QVariant sipQSqlResult::sipProtectVirt_lastInsertId(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? QSqlResult::lastInsertId() : lastInsertId());
}


PyDoc_STRVAR(doc_QSqlResult_handle, "QSqlResult.handle() -> object");

extern "C" {static PyObject *meth_QSqlResult_handle(PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_handle(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlResult *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant((sipSelfWasArg ? sipCpp->QSqlResult::handle() : sipCpp->handle()));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_handle, doc_QSqlResult_handle);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_at, "QSqlResult.at() -> int");

extern "C" {static PyObject *meth_QSqlResult_at(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_at(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_at();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_at, doc_QSqlResult_at);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_lastQuery, "QSqlResult.lastQuery() -> str");

extern "C" {static PyObject *meth_QSqlResult_lastQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_lastQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtect_lastQuery());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_lastQuery, doc_QSqlResult_lastQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_lastError, "QSqlResult.lastError() -> QSqlError");

extern "C" {static PyObject *meth_QSqlResult_lastError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_lastError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            QSqlError*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlError(sipCpp->sipProtect_lastError());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlError,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_lastError, doc_QSqlResult_lastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_isValid, "QSqlResult.isValid() -> bool");

extern "C" {static PyObject *meth_QSqlResult_isValid(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_isValid(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_isValid, doc_QSqlResult_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_isActive, "QSqlResult.isActive() -> bool");

extern "C" {static PyObject *meth_QSqlResult_isActive(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_isActive(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_isActive();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_isActive, doc_QSqlResult_isActive);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_isSelect, "QSqlResult.isSelect() -> bool");

extern "C" {static PyObject *meth_QSqlResult_isSelect(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_isSelect(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_isSelect();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_isSelect, doc_QSqlResult_isSelect);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_isForwardOnly, "QSqlResult.isForwardOnly() -> bool");

extern "C" {static PyObject *meth_QSqlResult_isForwardOnly(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_isForwardOnly(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_isForwardOnly();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_isForwardOnly, doc_QSqlResult_isForwardOnly);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_driver, "QSqlResult.driver() -> QSqlDriver");

extern "C" {static PyObject *meth_QSqlResult_driver(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_driver(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            const QSqlDriver*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_driver();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QSqlDriver *>(sipRes),sipType_QSqlDriver,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_driver, doc_QSqlResult_driver);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_setAt, "QSqlResult.setAt(int)");

extern "C" {static PyObject *meth_QSqlResult_setAt(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_setAt(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setAt(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_setAt, doc_QSqlResult_setAt);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_setActive, "QSqlResult.setActive(bool)");

extern "C" {static PyObject *meth_QSqlResult_setActive(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_setActive(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setActive(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_setActive, doc_QSqlResult_setActive);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_setLastError, "QSqlResult.setLastError(QSqlError)");

extern "C" {static PyObject *meth_QSqlResult_setLastError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_setLastError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlError* a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QSqlError, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setLastError(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_setLastError, doc_QSqlResult_setLastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_setQuery, "QSqlResult.setQuery(str)");

extern "C" {static PyObject *meth_QSqlResult_setQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_setQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setQuery(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_setQuery, doc_QSqlResult_setQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_setSelect, "QSqlResult.setSelect(bool)");

extern "C" {static PyObject *meth_QSqlResult_setSelect(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_setSelect(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setSelect(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_setSelect, doc_QSqlResult_setSelect);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_setForwardOnly, "QSqlResult.setForwardOnly(bool)");

extern "C" {static PyObject *meth_QSqlResult_setForwardOnly(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_setForwardOnly(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setForwardOnly(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_setForwardOnly, doc_QSqlResult_setForwardOnly);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_exec_, "QSqlResult.exec_() -> bool");

extern "C" {static PyObject *meth_QSqlResult_exec_(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_exec_(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_exec(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_exec_, doc_QSqlResult_exec_);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_exec, "QSqlResult.exec() -> bool");

extern "C" {static PyObject *meth_QSqlResult_exec(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_exec(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_exec(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_exec, doc_QSqlResult_exec);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_prepare, "QSqlResult.prepare(str) -> bool");

extern "C" {static PyObject *meth_QSqlResult_prepare(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_prepare(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_prepare(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_prepare, doc_QSqlResult_prepare);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_savePrepare, "QSqlResult.savePrepare(str) -> bool");

extern "C" {static PyObject *meth_QSqlResult_savePrepare(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_savePrepare(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_savePrepare(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_savePrepare, doc_QSqlResult_savePrepare);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_bindValue, "QSqlResult.bindValue(int, object, QSql.ParamType)\n"
    "QSqlResult.bindValue(str, object, QSql.ParamType)");

extern "C" {static PyObject *meth_QSqlResult_bindValue(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_bindValue(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        const QVariant* a1;
        int a1State = 0;
        QSql::ParamType* a2;
        int a2State = 0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiJ1J1", &sipSelf, sipType_QSqlResult, &sipCpp, &a0, sipType_QVariant,&a1, &a1State, sipType_QSql_ParamType, &a2, &a2State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_bindValue(sipSelfWasArg,a0,*a1,*a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);
            sipReleaseType(a2,sipType_QSql_ParamType,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QVariant* a1;
        int a1State = 0;
        QSql::ParamType* a2;
        int a2State = 0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1J1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant,&a1, &a1State, sipType_QSql_ParamType, &a2, &a2State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_bindValue(sipSelfWasArg,*a0,*a1,*a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);
            sipReleaseType(a2,sipType_QSql_ParamType,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_bindValue, doc_QSqlResult_bindValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_addBindValue, "QSqlResult.addBindValue(object, QSql.ParamType)");

extern "C" {static PyObject *meth_QSqlResult_addBindValue(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_addBindValue(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QVariant* a0;
        int a0State = 0;
        QSql::ParamType* a1;
        int a1State = 0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QVariant,&a0, &a0State, sipType_QSql_ParamType, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_addBindValue(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);
            sipReleaseType(a1,sipType_QSql_ParamType,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_addBindValue, doc_QSqlResult_addBindValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_boundValue, "QSqlResult.boundValue(str) -> object\n"
    "QSqlResult.boundValue(int) -> object");

extern "C" {static PyObject *meth_QSqlResult_boundValue(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_boundValue(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->sipProtect_boundValue(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    {
        int a0;
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->sipProtect_boundValue(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_boundValue, doc_QSqlResult_boundValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_bindValueType, "QSqlResult.bindValueType(str) -> QSql.ParamType\n"
    "QSqlResult.bindValueType(int) -> QSql.ParamType");

extern "C" {static PyObject *meth_QSqlResult_bindValueType(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_bindValueType(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSql::ParamType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSql::ParamType(sipCpp->sipProtect_bindValueType(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    {
        int a0;
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            QSql::ParamType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSql::ParamType(sipCpp->sipProtect_bindValueType(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_bindValueType, doc_QSqlResult_bindValueType);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_boundValueCount, "QSqlResult.boundValueCount() -> int");

extern "C" {static PyObject *meth_QSqlResult_boundValueCount(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_boundValueCount(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_boundValueCount();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_boundValueCount, doc_QSqlResult_boundValueCount);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_boundValues, "QSqlResult.boundValues() -> list-of-QVariant");

extern "C" {static PyObject *meth_QSqlResult_boundValues(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_boundValues(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            QVector<QVariant>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = &sipCpp->sipProtect_boundValues();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QVector_0100QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_boundValues, doc_QSqlResult_boundValues);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_executedQuery, "QSqlResult.executedQuery() -> str");

extern "C" {static PyObject *meth_QSqlResult_executedQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_executedQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtect_executedQuery());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_executedQuery, doc_QSqlResult_executedQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_boundValueName, "QSqlResult.boundValueName(int) -> str");

extern "C" {static PyObject *meth_QSqlResult_boundValueName(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_boundValueName(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtect_boundValueName(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_boundValueName, doc_QSqlResult_boundValueName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_clear, "QSqlResult.clear()");

extern "C" {static PyObject *meth_QSqlResult_clear(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_clear(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_clear();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_clear, doc_QSqlResult_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_hasOutValues, "QSqlResult.hasOutValues() -> bool");

extern "C" {static PyObject *meth_QSqlResult_hasOutValues(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_hasOutValues(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_hasOutValues();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_hasOutValues, doc_QSqlResult_hasOutValues);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_bindingSyntax, "QSqlResult.bindingSyntax() -> QSqlResult.BindingSyntax");

extern "C" {static PyObject *meth_QSqlResult_bindingSyntax(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_bindingSyntax(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_bindingSyntax();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QSqlResult_BindingSyntax);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_bindingSyntax, doc_QSqlResult_bindingSyntax);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_data, "QSqlResult.data(int) -> object");

extern "C" {static PyObject *meth_QSqlResult_data(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_data(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        int a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            QVariant*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_data);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->sipProtect_data(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_data, doc_QSqlResult_data);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_isNull, "QSqlResult.isNull(int) -> bool");

extern "C" {static PyObject *meth_QSqlResult_isNull(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_isNull(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        int a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_isNull);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_isNull(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_isNull, doc_QSqlResult_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_reset, "QSqlResult.reset(str) -> bool");

extern "C" {static PyObject *meth_QSqlResult_reset(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_reset(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QString* a0;
        int a0State = 0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlResult, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_reset);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_reset(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_reset, doc_QSqlResult_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_fetch, "QSqlResult.fetch(int) -> bool");

extern "C" {static PyObject *meth_QSqlResult_fetch(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_fetch(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        int a0;
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlResult, &sipCpp, &a0))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_fetch);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_fetch(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_fetch, doc_QSqlResult_fetch);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_fetchNext, "QSqlResult.fetchNext() -> bool");

extern "C" {static PyObject *meth_QSqlResult_fetchNext(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_fetchNext(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_fetchNext(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_fetchNext, doc_QSqlResult_fetchNext);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_fetchPrevious, "QSqlResult.fetchPrevious() -> bool");

extern "C" {static PyObject *meth_QSqlResult_fetchPrevious(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_fetchPrevious(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_fetchPrevious(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_fetchPrevious, doc_QSqlResult_fetchPrevious);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_fetchFirst, "QSqlResult.fetchFirst() -> bool");

extern "C" {static PyObject *meth_QSqlResult_fetchFirst(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_fetchFirst(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_fetchFirst);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_fetchFirst();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_fetchFirst, doc_QSqlResult_fetchFirst);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_fetchLast, "QSqlResult.fetchLast() -> bool");

extern "C" {static PyObject *meth_QSqlResult_fetchLast(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_fetchLast(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_fetchLast);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_fetchLast();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_fetchLast, doc_QSqlResult_fetchLast);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_size, "QSqlResult.size() -> int");

extern "C" {static PyObject *meth_QSqlResult_size(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_size(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            int sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_size);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_size();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_size, doc_QSqlResult_size);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_numRowsAffected, "QSqlResult.numRowsAffected() -> int");

extern "C" {static PyObject *meth_QSqlResult_numRowsAffected(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_numRowsAffected(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            int sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlResult, sipName_numRowsAffected);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_numRowsAffected();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_numRowsAffected, doc_QSqlResult_numRowsAffected);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_record, "QSqlResult.record() -> QSqlRecord");

extern "C" {static PyObject *meth_QSqlResult_record(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_record(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            QSqlRecord*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlRecord(sipCpp->sipProtectVirt_record(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlRecord,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_record, doc_QSqlResult_record);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlResult_lastInsertId, "QSqlResult.lastInsertId() -> object");

extern "C" {static PyObject *meth_QSqlResult_lastInsertId(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlResult_lastInsertId(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const sipQSqlResult *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlResult, &sipCpp))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->sipProtectVirt_lastInsertId(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlResult, sipName_lastInsertId, doc_QSqlResult_lastInsertId);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlResult(void *, const sipTypeDef *);}
static void *cast_QSqlResult(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlResult)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlResult(void *, int);}
static void release_QSqlResult(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQSqlResult *>(sipCppV);
    else
        delete reinterpret_cast<QSqlResult *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSqlResult(sipSimpleWrapper *);}
static void dealloc_QSqlResult(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlResult *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlResult(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlResult(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlResult(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQSqlResult *sipCpp = 0;

    {
        const QSqlDriver* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8", sipType_QSqlDriver, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlResult(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QSqlResult[] = {
    {SIP_MLNAME_CAST(sipName_addBindValue), (PyCFunction)meth_QSqlResult_addBindValue, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_addBindValue)},
    {SIP_MLNAME_CAST(sipName_at), (PyCFunction)meth_QSqlResult_at, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_at)},
    {SIP_MLNAME_CAST(sipName_bindValue), (PyCFunction)meth_QSqlResult_bindValue, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_bindValue)},
    {SIP_MLNAME_CAST(sipName_bindValueType), (PyCFunction)meth_QSqlResult_bindValueType, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_bindValueType)},
    {SIP_MLNAME_CAST(sipName_bindingSyntax), (PyCFunction)meth_QSqlResult_bindingSyntax, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_bindingSyntax)},
    {SIP_MLNAME_CAST(sipName_boundValue), (PyCFunction)meth_QSqlResult_boundValue, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_boundValue)},
    {SIP_MLNAME_CAST(sipName_boundValueCount), (PyCFunction)meth_QSqlResult_boundValueCount, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_boundValueCount)},
    {SIP_MLNAME_CAST(sipName_boundValueName), (PyCFunction)meth_QSqlResult_boundValueName, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_boundValueName)},
    {SIP_MLNAME_CAST(sipName_boundValues), (PyCFunction)meth_QSqlResult_boundValues, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_boundValues)},
    {SIP_MLNAME_CAST(sipName_clear), (PyCFunction)meth_QSqlResult_clear, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_clear)},
    {SIP_MLNAME_CAST(sipName_data), (PyCFunction)meth_QSqlResult_data, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_data)},
    {SIP_MLNAME_CAST(sipName_driver), (PyCFunction)meth_QSqlResult_driver, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_driver)},
    {SIP_MLNAME_CAST(sipName_exec), (PyCFunction)meth_QSqlResult_exec, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_exec)},
    {SIP_MLNAME_CAST(sipName_exec_), (PyCFunction)meth_QSqlResult_exec_, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_exec_)},
    {SIP_MLNAME_CAST(sipName_executedQuery), (PyCFunction)meth_QSqlResult_executedQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_executedQuery)},
    {SIP_MLNAME_CAST(sipName_fetch), (PyCFunction)meth_QSqlResult_fetch, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_fetch)},
    {SIP_MLNAME_CAST(sipName_fetchFirst), (PyCFunction)meth_QSqlResult_fetchFirst, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_fetchFirst)},
    {SIP_MLNAME_CAST(sipName_fetchLast), (PyCFunction)meth_QSqlResult_fetchLast, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_fetchLast)},
    {SIP_MLNAME_CAST(sipName_fetchNext), (PyCFunction)meth_QSqlResult_fetchNext, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_fetchNext)},
    {SIP_MLNAME_CAST(sipName_fetchPrevious), (PyCFunction)meth_QSqlResult_fetchPrevious, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_fetchPrevious)},
    {SIP_MLNAME_CAST(sipName_handle), meth_QSqlResult_handle, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlResult_handle)},
    {SIP_MLNAME_CAST(sipName_hasOutValues), (PyCFunction)meth_QSqlResult_hasOutValues, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_hasOutValues)},
    {SIP_MLNAME_CAST(sipName_isActive), (PyCFunction)meth_QSqlResult_isActive, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_isActive)},
    {SIP_MLNAME_CAST(sipName_isForwardOnly), (PyCFunction)meth_QSqlResult_isForwardOnly, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_isForwardOnly)},
    {SIP_MLNAME_CAST(sipName_isNull), (PyCFunction)meth_QSqlResult_isNull, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_isNull)},
    {SIP_MLNAME_CAST(sipName_isSelect), (PyCFunction)meth_QSqlResult_isSelect, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_isSelect)},
    {SIP_MLNAME_CAST(sipName_isValid), (PyCFunction)meth_QSqlResult_isValid, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_isValid)},
    {SIP_MLNAME_CAST(sipName_lastError), (PyCFunction)meth_QSqlResult_lastError, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_lastError)},
    {SIP_MLNAME_CAST(sipName_lastInsertId), (PyCFunction)meth_QSqlResult_lastInsertId, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_lastInsertId)},
    {SIP_MLNAME_CAST(sipName_lastQuery), (PyCFunction)meth_QSqlResult_lastQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_lastQuery)},
    {SIP_MLNAME_CAST(sipName_numRowsAffected), (PyCFunction)meth_QSqlResult_numRowsAffected, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_numRowsAffected)},
    {SIP_MLNAME_CAST(sipName_prepare), (PyCFunction)meth_QSqlResult_prepare, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_prepare)},
    {SIP_MLNAME_CAST(sipName_record), (PyCFunction)meth_QSqlResult_record, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_record)},
    {SIP_MLNAME_CAST(sipName_reset), (PyCFunction)meth_QSqlResult_reset, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_reset)},
    {SIP_MLNAME_CAST(sipName_savePrepare), (PyCFunction)meth_QSqlResult_savePrepare, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_savePrepare)},
    {SIP_MLNAME_CAST(sipName_setActive), (PyCFunction)meth_QSqlResult_setActive, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_setActive)},
    {SIP_MLNAME_CAST(sipName_setAt), (PyCFunction)meth_QSqlResult_setAt, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_setAt)},
    {SIP_MLNAME_CAST(sipName_setForwardOnly), (PyCFunction)meth_QSqlResult_setForwardOnly, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_setForwardOnly)},
    {SIP_MLNAME_CAST(sipName_setLastError), (PyCFunction)meth_QSqlResult_setLastError, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_setLastError)},
    {SIP_MLNAME_CAST(sipName_setQuery), (PyCFunction)meth_QSqlResult_setQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_setQuery)},
    {SIP_MLNAME_CAST(sipName_setSelect), (PyCFunction)meth_QSqlResult_setSelect, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_setSelect)},
    {SIP_MLNAME_CAST(sipName_size), (PyCFunction)meth_QSqlResult_size, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlResult_size)}
};

static sipEnumMemberDef enummembers_QSqlResult[] = {
    {sipName_NamedBinding, static_cast<int>(sipQSqlResult::NamedBinding), 26},
    {sipName_PositionalBinding, static_cast<int>(sipQSqlResult::PositionalBinding), 26},
};

PyDoc_STRVAR(doc_QSqlResult, "\1QSqlResult(QSqlDriver)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlResult = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_CLASS,
        sipNameNr_QSqlResult,
        {0}
    },
    {
        sipNameNr_QSqlResult,
        {0, 0, 1},
        42, methods_QSqlResult,
        2, enummembers_QSqlResult,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlResult,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    -1,
    0,
    0,
    init_type_QSqlResult,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlResult,
    0,
    0,
    0,
    release_QSqlResult,
    cast_QSqlResult,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 41 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrelationaltablemodel.sip"
#include <qsqlrelationaltablemodel.h>
#line 3488 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 3492 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 3495 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 3498 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 3501 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 3504 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqltablemodel.sip"
#include <qsqltablemodel.h>
#line 3507 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrelationaltablemodel.sip"
#include <qsqlrelationaltablemodel.h>
#line 3510 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 3513 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlquery.sip"
#include <qsqlquery.h>
#line 3516 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlindex.sip"
#include <qsqlindex.h>
#line 3519 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 3522 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 3525 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 3528 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qmimedata.sip"
#include <qmimedata.h>
#line 3531 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 139 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qhash.sip"
#include <qhash.h>
#line 3534 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 3537 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 3540 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 3543 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qdatastream.sip"
#include <qdatastream.h>
#line 3546 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 3549 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 3552 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 3555 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 139 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qmap.sip"
#include <qmap.h>
#line 3558 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 3561 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 3564 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 3567 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 3570 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 3573 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 3576 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 3579 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 3582 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 3585 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlRelationalTableModel : public QSqlRelationalTableModel
{
public:
    sipQSqlRelationalTableModel(QObject*,QSqlDatabase);
    virtual ~sipQSqlRelationalTableModel();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtect_resetInternalData();
    void sipProtect_encodeData(const QModelIndexList&,QDataStream&) const;
    bool sipProtect_decodeData(int,int,const QModelIndex&,QDataStream&);
    void sipProtect_beginInsertRows(const QModelIndex&,int,int);
    void sipProtect_endInsertRows();
    void sipProtect_beginRemoveRows(const QModelIndex&,int,int);
    void sipProtect_endRemoveRows();
    void sipProtect_beginInsertColumns(const QModelIndex&,int,int);
    void sipProtect_endInsertColumns();
    void sipProtect_beginRemoveColumns(const QModelIndex&,int,int);
    void sipProtect_endRemoveColumns();
    QModelIndexList sipProtect_persistentIndexList() const;
    void sipProtect_reset();
    void sipProtect_changePersistentIndex(const QModelIndex&,const QModelIndex&);
    void sipProtect_changePersistentIndexList(const QModelIndexList&,const QModelIndexList&);
    QModelIndex sipProtect_createIndex(int,int,void*) const;
    bool sipProtect_beginMoveRows(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveRows();
    bool sipProtect_beginMoveColumns(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveColumns();
    void sipProtect_beginResetModel();
    void sipProtect_endResetModel();
    void sipProtect_setRoleNames(const QHash<int,QByteArray>&);
    void sipProtectVirt_queryChange(bool);
    void sipProtect_setLastError(const QSqlError&);
    bool sipProtectVirt_deleteRowFromTable(bool,int);
    void sipProtect_setPrimaryKey(const QSqlIndex&);
    void sipProtect_setQuery(const QSqlQuery&);
    QModelIndex sipProtect_indexInQuery(const QModelIndex&) const;
    QString sipProtectVirt_selectStatement(bool) const;
    bool sipProtectVirt_updateRowInTable(bool,int,const QSqlRecord&);
    QString sipProtectVirt_orderByClause(bool) const;
    bool sipProtectVirt_insertRowIntoTable(bool,const QSqlRecord&);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    QSize span(const QModelIndex&) const;
    QModelIndexList match(const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags) const;
    QModelIndex buddy(const QModelIndex&) const;
    Qt::DropActions supportedDropActions() const;
    QMimeData* mimeData(const QModelIndexList&) const;
    QStringList mimeTypes() const;
    bool setItemData(const QModelIndex&,const QMap<int,QVariant>&);
    QMap<int,QVariant> itemData(const QModelIndex&) const;
    bool dropMimeData(const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);
    QModelIndex index(int,int,const QModelIndex&) const;
    void queryChange();
    bool canFetchMore(const QModelIndex&) const;
    void fetchMore(const QModelIndex&);
    bool insertColumns(int,int,const QModelIndex&);
    bool setHeaderData(int,Qt::Orientation,const QVariant&,int);
    int columnCount(const QModelIndex&) const;
    bool deleteRowFromTable(int);
    void revert();
    bool submit();
    bool insertRows(int,int,const QModelIndex&);
    bool removeRows(int,int,const QModelIndex&);
    int rowCount(const QModelIndex&) const;
    void setFilter(const QString&);
    void setSort(int,Qt::SortOrder);
    void sort(int,Qt::SortOrder);
    void setEditStrategy(QSqlTableModel::EditStrategy);
    QVariant headerData(int,Qt::Orientation,int) const;
    Qt::ItemFlags flags(const QModelIndex&) const;
    bool insertRowIntoTable(const QSqlRecord&);
    QString orderByClause() const;
    bool updateRowInTable(int,const QSqlRecord&);
    QString selectStatement() const;
    bool removeColumns(int,int,const QModelIndex&);
    void revertRow(int);
    QSqlTableModel* relationModel(int) const;
    void setRelation(int,const QSqlRelation&);
    void setTable(const QString&);
    bool select();
    void clear();
    bool setData(const QModelIndex&,const QVariant&,int);
    QVariant data(const QModelIndex&,int) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlRelationalTableModel(const sipQSqlRelationalTableModel &);
    sipQSqlRelationalTableModel &operator = (const sipQSqlRelationalTableModel &);

    char sipPyMethods[48];
};

sipQSqlRelationalTableModel::sipQSqlRelationalTableModel(QObject*a0,QSqlDatabase a1): QSqlRelationalTableModel(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlRelationalTableModel::~sipQSqlRelationalTableModel()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQSqlRelationalTableModel::metaObject() const
{
    return sip_QtSql_qt_metaobject(sipPySelf,sipType_QSqlRelationalTableModel);
}

int sipQSqlRelationalTableModel::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QSqlRelationalTableModel::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtSql_qt_metacall(sipPySelf,sipType_QSqlRelationalTableModel,_c,_id,_a);

    return _id;
}

void *sipQSqlRelationalTableModel::qt_metacast(const char *_clname)
{
    return (sip_QtSql_qt_metacast(sipPySelf, sipType_QSqlRelationalTableModel, _clname)) ? this : QSqlRelationalTableModel::qt_metacast(_clname);
}

void sipQSqlRelationalTableModel::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtSql_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtSql_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtSql_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalTableModel::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QSqlRelationalTableModel::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtSql_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

bool sipQSqlRelationalTableModel::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QSqlRelationalTableModel::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtSql_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QSize sipQSqlRelationalTableModel::span(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,NULL,sipName_span);

    if (!sipMeth)
        return QSqlRelationalTableModel::span(a0);

    typedef QSize (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_47)(sipModuleAPI_QtSql_QtCore->em_virthandlers[47]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QModelIndexList sipQSqlRelationalTableModel::match(const QModelIndex& a0,int a1,const QVariant& a2,int a3,Qt::MatchFlags a4) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,NULL,sipName_match);

    if (!sipMeth)
        return QSqlRelationalTableModel::match(a0,a1,a2,a3,a4);

    typedef QList<QModelIndex> (*sipVH_QtCore_48)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags);

    return ((sipVH_QtCore_48)(sipModuleAPI_QtSql_QtCore->em_virthandlers[48]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipQSqlRelationalTableModel::buddy(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,NULL,sipName_buddy);

    if (!sipMeth)
        return QSqlRelationalTableModel::buddy(a0);

    typedef QModelIndex (*sipVH_QtCore_44)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_44)(sipModuleAPI_QtSql_QtCore->em_virthandlers[44]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

Qt::DropActions sipQSqlRelationalTableModel::supportedDropActions() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,NULL,sipName_supportedDropActions);

    if (!sipMeth)
        return QSqlRelationalTableModel::supportedDropActions();

    typedef Qt::DropActions (*sipVH_QtCore_53)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_53)(sipModuleAPI_QtSql_QtCore->em_virthandlers[53]))(sipGILState, 0, sipPySelf, sipMeth);
}

QMimeData* sipQSqlRelationalTableModel::mimeData(const QModelIndexList& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,NULL,sipName_mimeData);

    if (!sipMeth)
        return QSqlRelationalTableModel::mimeData(a0);

    typedef QMimeData* (*sipVH_QtCore_54)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QList<QModelIndex>&);

    return ((sipVH_QtCore_54)(sipModuleAPI_QtSql_QtCore->em_virthandlers[54]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QStringList sipQSqlRelationalTableModel::mimeTypes() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,NULL,sipName_mimeTypes);

    if (!sipMeth)
        return QSqlRelationalTableModel::mimeTypes();

    typedef QStringList (*sipVH_QtCore_27)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_27)(sipModuleAPI_QtSql_QtCore->em_virthandlers[27]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlRelationalTableModel::setItemData(const QModelIndex& a0,const QMap<int,QVariant>& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[13],sipPySelf,NULL,sipName_setItemData);

    if (!sipMeth)
        return QSqlRelationalTableModel::setItemData(a0,a1);

    typedef bool (*sipVH_QtCore_55)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,const QMap<int,QVariant>&);

    return ((sipVH_QtCore_55)(sipModuleAPI_QtSql_QtCore->em_virthandlers[55]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QMap<int,QVariant> sipQSqlRelationalTableModel::itemData(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[14]),sipPySelf,NULL,sipName_itemData);

    if (!sipMeth)
        return QSqlRelationalTableModel::itemData(a0);

    typedef QMap<int,QVariant> (*sipVH_QtCore_56)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_56)(sipModuleAPI_QtSql_QtCore->em_virthandlers[56]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalTableModel::dropMimeData(const QMimeData*a0,Qt::DropAction a1,int a2,int a3,const QModelIndex& a4)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,NULL,sipName_dropMimeData);

    if (!sipMeth)
        return QSqlRelationalTableModel::dropMimeData(a0,a1,a2,a3,a4);

    typedef bool (*sipVH_QtCore_45)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);

    return ((sipVH_QtCore_45)(sipModuleAPI_QtSql_QtCore->em_virthandlers[45]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipQSqlRelationalTableModel::index(int a0,int a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[16]),sipPySelf,NULL,sipName_index);

    if (!sipMeth)
        return QSqlRelationalTableModel::index(a0,a1,a2);

    typedef QModelIndex (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_46)(sipModuleAPI_QtSql_QtCore->em_virthandlers[46]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlRelationalTableModel::queryChange()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[17],sipPySelf,NULL,sipName_queryChange);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::queryChange();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlRelationalTableModel::canFetchMore(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[18]),sipPySelf,NULL,sipName_canFetchMore);

    if (!sipMeth)
        return QSqlRelationalTableModel::canFetchMore(a0);

    typedef bool (*sipVH_QtCore_42)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_42)(sipModuleAPI_QtSql_QtCore->em_virthandlers[42]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::fetchMore(const QModelIndex& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[19],sipPySelf,NULL,sipName_fetchMore);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::fetchMore(a0);
        return;
    }

    typedef void (*sipVH_QtCore_51)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    ((sipVH_QtCore_51)(sipModuleAPI_QtSql_QtCore->em_virthandlers[51]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalTableModel::insertColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[20],sipPySelf,NULL,sipName_insertColumns);

    if (!sipMeth)
        return QSqlRelationalTableModel::insertColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlRelationalTableModel::setHeaderData(int a0,Qt::Orientation a1,const QVariant& a2,int a3)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,NULL,sipName_setHeaderData);

    if (!sipMeth)
        return QSqlRelationalTableModel::setHeaderData(a0,a1,a2,a3);

    typedef bool (*sipVH_QtCore_57)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,const QVariant&,int);

    return ((sipVH_QtCore_57)(sipModuleAPI_QtSql_QtCore->em_virthandlers[57]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

int sipQSqlRelationalTableModel::columnCount(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[22]),sipPySelf,NULL,sipName_columnCount);

    if (!sipMeth)
        return QSqlRelationalTableModel::columnCount(a0);

    typedef int (*sipVH_QtCore_43)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_43)(sipModuleAPI_QtSql_QtCore->em_virthandlers[43]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalTableModel::deleteRowFromTable(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[23],sipPySelf,NULL,sipName_deleteRowFromTable);

    if (!sipMeth)
        return QSqlRelationalTableModel::deleteRowFromTable(a0);

    typedef bool (*sipVH_QtCore_23)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return ((sipVH_QtCore_23)(sipModuleAPI_QtSql_QtCore->em_virthandlers[23]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::revert()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[24],sipPySelf,NULL,sipName_revert);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::revert();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlRelationalTableModel::submit()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[25],sipPySelf,NULL,sipName_submit);

    if (!sipMeth)
        return QSqlRelationalTableModel::submit();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlRelationalTableModel::insertRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[26],sipPySelf,NULL,sipName_insertRows);

    if (!sipMeth)
        return QSqlRelationalTableModel::insertRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlRelationalTableModel::removeRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[27],sipPySelf,NULL,sipName_removeRows);

    if (!sipMeth)
        return QSqlRelationalTableModel::removeRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

int sipQSqlRelationalTableModel::rowCount(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[28]),sipPySelf,NULL,sipName_rowCount);

    if (!sipMeth)
        return QSqlRelationalTableModel::rowCount(a0);

    typedef int (*sipVH_QtCore_43)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_43)(sipModuleAPI_QtSql_QtCore->em_virthandlers[43]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::setFilter(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[29],sipPySelf,NULL,sipName_setFilter);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::setFilter(a0);
        return;
    }

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtSql_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::setSort(int a0,Qt::SortOrder a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[30],sipPySelf,NULL,sipName_setSort);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::setSort(a0,a1);
        return;
    }

    typedef void (*sipVH_QtCore_49)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::SortOrder);

    ((sipVH_QtCore_49)(sipModuleAPI_QtSql_QtCore->em_virthandlers[49]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlRelationalTableModel::sort(int a0,Qt::SortOrder a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[31],sipPySelf,NULL,sipName_sort);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::sort(a0,a1);
        return;
    }

    typedef void (*sipVH_QtCore_49)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::SortOrder);

    ((sipVH_QtCore_49)(sipModuleAPI_QtSql_QtCore->em_virthandlers[49]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlRelationalTableModel::setEditStrategy(QSqlTableModel::EditStrategy a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[32],sipPySelf,NULL,sipName_setEditStrategy);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::setEditStrategy(a0);
        return;
    }

    extern void sipVH_QtSql_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QSqlTableModel::EditStrategy);

    sipVH_QtSql_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVariant sipQSqlRelationalTableModel::headerData(int a0,Qt::Orientation a1,int a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[33]),sipPySelf,NULL,sipName_headerData);

    if (!sipMeth)
        return QSqlRelationalTableModel::headerData(a0,a1,a2);

    typedef QVariant (*sipVH_QtCore_58)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,int);

    return ((sipVH_QtCore_58)(sipModuleAPI_QtSql_QtCore->em_virthandlers[58]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

Qt::ItemFlags sipQSqlRelationalTableModel::flags(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[34]),sipPySelf,NULL,sipName_flags);

    if (!sipMeth)
        return QSqlRelationalTableModel::flags(a0);

    typedef Qt::ItemFlags (*sipVH_QtCore_50)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_50)(sipModuleAPI_QtSql_QtCore->em_virthandlers[50]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalTableModel::insertRowIntoTable(const QSqlRecord& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[35],sipPySelf,NULL,sipName_insertRowIntoTable);

    if (!sipMeth)
        return QSqlRelationalTableModel::insertRowIntoTable(a0);

    extern bool sipVH_QtSql_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QSqlRecord&);

    return sipVH_QtSql_0(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QString sipQSqlRelationalTableModel::orderByClause() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[36]),sipPySelf,NULL,sipName_orderByClause);

    if (!sipMeth)
        return QSqlRelationalTableModel::orderByClause();

    typedef QString (*sipVH_QtCore_62)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_62)(sipModuleAPI_QtSql_QtCore->em_virthandlers[62]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlRelationalTableModel::updateRowInTable(int a0,const QSqlRecord& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[37],sipPySelf,NULL,sipName_updateRowInTable);

    if (!sipMeth)
        return QSqlRelationalTableModel::updateRowInTable(a0,a1);

    extern bool sipVH_QtSql_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,const QSqlRecord&);

    return sipVH_QtSql_1(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QString sipQSqlRelationalTableModel::selectStatement() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[38]),sipPySelf,NULL,sipName_selectStatement);

    if (!sipMeth)
        return QSqlRelationalTableModel::selectStatement();

    typedef QString (*sipVH_QtCore_62)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_62)(sipModuleAPI_QtSql_QtCore->em_virthandlers[62]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlRelationalTableModel::removeColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[39],sipPySelf,NULL,sipName_removeColumns);

    if (!sipMeth)
        return QSqlRelationalTableModel::removeColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlRelationalTableModel::revertRow(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[40],sipPySelf,NULL,sipName_revertRow);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::revertRow(a0);
        return;
    }

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtSql_QtCore->em_virthandlers[4]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QSqlTableModel* sipQSqlRelationalTableModel::relationModel(int a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[41]),sipPySelf,NULL,sipName_relationModel);

    if (!sipMeth)
        return QSqlRelationalTableModel::relationModel(a0);

    extern QSqlTableModel* sipVH_QtSql_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return sipVH_QtSql_8(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalTableModel::setRelation(int a0,const QSqlRelation& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[42],sipPySelf,NULL,sipName_setRelation);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::setRelation(a0,a1);
        return;
    }

    extern void sipVH_QtSql_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,const QSqlRelation&);

    sipVH_QtSql_9(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlRelationalTableModel::setTable(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[43],sipPySelf,NULL,sipName_setTable);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::setTable(a0);
        return;
    }

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtSql_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalTableModel::select()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[44],sipPySelf,NULL,sipName_select);

    if (!sipMeth)
        return QSqlRelationalTableModel::select();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQSqlRelationalTableModel::clear()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[45],sipPySelf,NULL,sipName_clear);

    if (!sipMeth)
    {
        QSqlRelationalTableModel::clear();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlRelationalTableModel::setData(const QModelIndex& a0,const QVariant& a1,int a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[46],sipPySelf,NULL,sipName_setData);

    if (!sipMeth)
        return QSqlRelationalTableModel::setData(a0,a1,a2);

    typedef bool (*sipVH_QtCore_59)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,const QVariant&,int);

    return ((sipVH_QtCore_59)(sipModuleAPI_QtSql_QtCore->em_virthandlers[59]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

QVariant sipQSqlRelationalTableModel::data(const QModelIndex& a0,int a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[47]),sipPySelf,NULL,sipName_data);

    if (!sipMeth)
        return QSqlRelationalTableModel::data(a0,a1);

    typedef QVariant (*sipVH_QtCore_60)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int);

    return ((sipVH_QtCore_60)(sipModuleAPI_QtSql_QtCore->em_virthandlers[60]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QObject* sipQSqlRelationalTableModel::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQSqlRelationalTableModel::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQSqlRelationalTableModel::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQSqlRelationalTableModel::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQSqlRelationalTableModel::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQSqlRelationalTableModel::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQSqlRelationalTableModel::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQSqlRelationalTableModel::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

void sipQSqlRelationalTableModel::sipProtect_resetInternalData()
{
    QAbstractItemModel::resetInternalData();
}

void sipQSqlRelationalTableModel::sipProtect_encodeData(const QModelIndexList& a0,QDataStream& a1) const
{
    QAbstractItemModel::encodeData(a0,a1);
}

bool sipQSqlRelationalTableModel::sipProtect_decodeData(int a0,int a1,const QModelIndex& a2,QDataStream& a3)
{
    return QAbstractItemModel::decodeData(a0,a1,a2,a3);
}

void sipQSqlRelationalTableModel::sipProtect_beginInsertRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertRows(a0,a1,a2);
}

void sipQSqlRelationalTableModel::sipProtect_endInsertRows()
{
    QAbstractItemModel::endInsertRows();
}

void sipQSqlRelationalTableModel::sipProtect_beginRemoveRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveRows(a0,a1,a2);
}

void sipQSqlRelationalTableModel::sipProtect_endRemoveRows()
{
    QAbstractItemModel::endRemoveRows();
}

void sipQSqlRelationalTableModel::sipProtect_beginInsertColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertColumns(a0,a1,a2);
}

void sipQSqlRelationalTableModel::sipProtect_endInsertColumns()
{
    QAbstractItemModel::endInsertColumns();
}

void sipQSqlRelationalTableModel::sipProtect_beginRemoveColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveColumns(a0,a1,a2);
}

void sipQSqlRelationalTableModel::sipProtect_endRemoveColumns()
{
    QAbstractItemModel::endRemoveColumns();
}

QModelIndexList sipQSqlRelationalTableModel::sipProtect_persistentIndexList() const
{
    return QAbstractItemModel::persistentIndexList();
}

void sipQSqlRelationalTableModel::sipProtect_reset()
{
    QAbstractItemModel::reset();
}

void sipQSqlRelationalTableModel::sipProtect_changePersistentIndex(const QModelIndex& a0,const QModelIndex& a1)
{
    QAbstractItemModel::changePersistentIndex(a0,a1);
}

void sipQSqlRelationalTableModel::sipProtect_changePersistentIndexList(const QModelIndexList& a0,const QModelIndexList& a1)
{
    QAbstractItemModel::changePersistentIndexList(a0,a1);
}

QModelIndex sipQSqlRelationalTableModel::sipProtect_createIndex(int a0,int a1,void*a2) const
{
    return QAbstractItemModel::createIndex(a0,a1,a2);
}

bool sipQSqlRelationalTableModel::sipProtect_beginMoveRows(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveRows(a0,a1,a2,a3,a4);
}

void sipQSqlRelationalTableModel::sipProtect_endMoveRows()
{
    QAbstractItemModel::endMoveRows();
}

bool sipQSqlRelationalTableModel::sipProtect_beginMoveColumns(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveColumns(a0,a1,a2,a3,a4);
}

void sipQSqlRelationalTableModel::sipProtect_endMoveColumns()
{
    QAbstractItemModel::endMoveColumns();
}

void sipQSqlRelationalTableModel::sipProtect_beginResetModel()
{
    QAbstractItemModel::beginResetModel();
}

void sipQSqlRelationalTableModel::sipProtect_endResetModel()
{
    QAbstractItemModel::endResetModel();
}

void sipQSqlRelationalTableModel::sipProtect_setRoleNames(const QHash<int,QByteArray>& a0)
{
    QAbstractItemModel::setRoleNames(a0);
}

void sipQSqlRelationalTableModel::sipProtectVirt_queryChange(bool sipSelfWasArg)
{
    (sipSelfWasArg ? QSqlQueryModel::queryChange() : queryChange());
}

void sipQSqlRelationalTableModel::sipProtect_setLastError(const QSqlError& a0)
{
    QSqlQueryModel::setLastError(a0);
}

bool sipQSqlRelationalTableModel::sipProtectVirt_deleteRowFromTable(bool sipSelfWasArg,int a0)
{
    return (sipSelfWasArg ? QSqlTableModel::deleteRowFromTable(a0) : deleteRowFromTable(a0));
}

void sipQSqlRelationalTableModel::sipProtect_setPrimaryKey(const QSqlIndex& a0)
{
    QSqlTableModel::setPrimaryKey(a0);
}

void sipQSqlRelationalTableModel::sipProtect_setQuery(const QSqlQuery& a0)
{
    QSqlTableModel::setQuery(a0);
}

QModelIndex sipQSqlRelationalTableModel::sipProtect_indexInQuery(const QModelIndex& a0) const
{
    return QSqlTableModel::indexInQuery(a0);
}

QString sipQSqlRelationalTableModel::sipProtectVirt_selectStatement(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? QSqlRelationalTableModel::selectStatement() : selectStatement());
}

bool sipQSqlRelationalTableModel::sipProtectVirt_updateRowInTable(bool sipSelfWasArg,int a0,const QSqlRecord& a1)
{
    return (sipSelfWasArg ? QSqlRelationalTableModel::updateRowInTable(a0,a1) : updateRowInTable(a0,a1));
}

QString sipQSqlRelationalTableModel::sipProtectVirt_orderByClause(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? QSqlRelationalTableModel::orderByClause() : orderByClause());
}

bool sipQSqlRelationalTableModel::sipProtectVirt_insertRowIntoTable(bool sipSelfWasArg,const QSqlRecord& a0)
{
    return (sipSelfWasArg ? QSqlRelationalTableModel::insertRowIntoTable(a0) : insertRowIntoTable(a0));
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_sender, "QSqlRelationalTableModel.sender() -> QObject");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            QObject*sipRes = 0;

#line 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (helper)
            sipRes = helper(sipRes);
#line 4749 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_sender, doc_QSqlRelationalTableModel_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_receivers, "QSqlRelationalTableModel.receivers(SIGNAL()) -> int");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        char* a0;
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 4794 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_receivers, doc_QSqlRelationalTableModel_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_timerEvent, "QSqlRelationalTableModel.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_timerEvent, doc_QSqlRelationalTableModel_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_childEvent, "QSqlRelationalTableModel.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_childEvent, doc_QSqlRelationalTableModel_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_customEvent, "QSqlRelationalTableModel.customEvent(QEvent)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_customEvent, doc_QSqlRelationalTableModel_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_connectNotify, "QSqlRelationalTableModel.connectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_connectNotify, doc_QSqlRelationalTableModel_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_disconnectNotify, "QSqlRelationalTableModel.disconnectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_disconnectNotify, doc_QSqlRelationalTableModel_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_senderSignalIndex, "QSqlRelationalTableModel.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_senderSignalIndex, doc_QSqlRelationalTableModel_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_resetInternalData, "QSqlRelationalTableModel.resetInternalData()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_resetInternalData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_resetInternalData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_resetInternalData();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_resetInternalData, doc_QSqlRelationalTableModel_resetInternalData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_encodeData, "QSqlRelationalTableModel.encodeData(list-of-QModelIndex, QDataStream)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_encodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_encodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        QDataStream* a1;
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QDataStream, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_encodeData(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_encodeData, doc_QSqlRelationalTableModel_encodeData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_decodeData, "QSqlRelationalTableModel.decodeData(int, int, QModelIndex, QDataStream) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_decodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_decodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        const QModelIndex* a2;
        QDataStream* a3;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiiJ9J9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2, sipType_QDataStream, &a3))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_decodeData(a0,a1,*a2,*a3);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_decodeData, doc_QSqlRelationalTableModel_decodeData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_beginInsertRows, "QSqlRelationalTableModel.beginInsertRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_beginInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_beginInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginInsertRows(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_beginInsertRows, doc_QSqlRelationalTableModel_beginInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_endInsertRows, "QSqlRelationalTableModel.endInsertRows()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_endInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_endInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endInsertRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_endInsertRows, doc_QSqlRelationalTableModel_endInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_beginRemoveRows, "QSqlRelationalTableModel.beginRemoveRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_beginRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_beginRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginRemoveRows(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_beginRemoveRows, doc_QSqlRelationalTableModel_beginRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_endRemoveRows, "QSqlRelationalTableModel.endRemoveRows()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_endRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_endRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endRemoveRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_endRemoveRows, doc_QSqlRelationalTableModel_endRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_beginInsertColumns, "QSqlRelationalTableModel.beginInsertColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_beginInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_beginInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginInsertColumns(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_beginInsertColumns, doc_QSqlRelationalTableModel_beginInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_endInsertColumns, "QSqlRelationalTableModel.endInsertColumns()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_endInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_endInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endInsertColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_endInsertColumns, doc_QSqlRelationalTableModel_endInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_beginRemoveColumns, "QSqlRelationalTableModel.beginRemoveColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_beginRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_beginRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginRemoveColumns(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_beginRemoveColumns, doc_QSqlRelationalTableModel_beginRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_endRemoveColumns, "QSqlRelationalTableModel.endRemoveColumns()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_endRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_endRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endRemoveColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_endRemoveColumns, doc_QSqlRelationalTableModel_endRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_persistentIndexList, "QSqlRelationalTableModel.persistentIndexList() -> list-of-QModelIndex");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_persistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_persistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            QModelIndexList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QModelIndexList(sipCpp->sipProtect_persistentIndexList());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_persistentIndexList, doc_QSqlRelationalTableModel_persistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_reset, "QSqlRelationalTableModel.reset()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_reset(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_reset(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_reset();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_reset, doc_QSqlRelationalTableModel_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_changePersistentIndex, "QSqlRelationalTableModel.changePersistentIndex(QModelIndex, QModelIndex)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_changePersistentIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_changePersistentIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const QModelIndex* a1;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9J9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, sipType_QModelIndex, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_changePersistentIndex(*a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_changePersistentIndex, doc_QSqlRelationalTableModel_changePersistentIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_changePersistentIndexList, "QSqlRelationalTableModel.changePersistentIndexList(list-of-QModelIndex, list-of-QModelIndex)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_changePersistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_changePersistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        const QModelIndexList* a1;
        int a1State = 0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QList_0100QModelIndex,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_changePersistentIndexList(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);
            sipReleaseType(const_cast<QModelIndexList *>(a1),sipType_QList_0100QModelIndex,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_changePersistentIndexList, doc_QSqlRelationalTableModel_changePersistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_createIndex, "QSqlRelationalTableModel.createIndex(int, int, object object=0) -> QModelIndex");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_createIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_createIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        PyObject * a2 = 0;
        const sipQSqlRelationalTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_object,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|P0", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0, &a1, &a2))
        {
            QModelIndex*sipRes = 0;

#line 243 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
        // The Qt API is broken (and won't be fixed as it would break binary
        // compatibility) regarding the internal id of a model index on different
        // architectures (32 vs 64 bits).  We choose to work around the breakage as it
        // is fairly subtle and continues to catch people out.  Instead of letting Qt
        // convert betweed an integer id and a pointer id (the internal format used by
        // Qt) we let Python do it.
        
        void *ptr;
        
        if (a2)
        {
            // Try and convert it to a Python long and fallback to the object's
            // address if it fails.
            ptr = PyLong_AsVoidPtr(a2);
        
            if (PyErr_Occurred())
            {
                PyErr_Clear();
                ptr = a2;
            }
        }
        else
        {
            ptr = 0;
        }
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = new QModelIndex(sipCpp->createIndex(a0, a1, ptr));
        #else
        sipRes = new QModelIndex(sipCpp->sipProtect_createIndex(a0, a1, ptr));
        #endif
#line 5491 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromNewType(sipRes,sipType_QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_createIndex, doc_QSqlRelationalTableModel_createIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_beginMoveRows, "QSqlRelationalTableModel.beginMoveRows(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_beginMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_beginMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_beginMoveRows(*a0,a1,a2,*a3,a4);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_beginMoveRows, doc_QSqlRelationalTableModel_beginMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_endMoveRows, "QSqlRelationalTableModel.endMoveRows()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_endMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_endMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endMoveRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_endMoveRows, doc_QSqlRelationalTableModel_endMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_beginMoveColumns, "QSqlRelationalTableModel.beginMoveColumns(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_beginMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_beginMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_beginMoveColumns(*a0,a1,a2,*a3,a4);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_beginMoveColumns, doc_QSqlRelationalTableModel_beginMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_endMoveColumns, "QSqlRelationalTableModel.endMoveColumns()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_endMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_endMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endMoveColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_endMoveColumns, doc_QSqlRelationalTableModel_endMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_beginResetModel, "QSqlRelationalTableModel.beginResetModel()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_beginResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_beginResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginResetModel();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_beginResetModel, doc_QSqlRelationalTableModel_beginResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_endResetModel, "QSqlRelationalTableModel.endResetModel()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_endResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_endResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endResetModel();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_endResetModel, doc_QSqlRelationalTableModel_endResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setRoleNames, "QSqlRelationalTableModel.setRoleNames(dict-of-int-QByteArray)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setRoleNames(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setRoleNames(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QHash<int,QByteArray>* a0;
        int a0State = 0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QHash_1800_0100QByteArray,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setRoleNames(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QHash<int,QByteArray> *>(a0),sipType_QHash_1800_0100QByteArray,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setRoleNames, doc_QSqlRelationalTableModel_setRoleNames);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_queryChange, "QSqlRelationalTableModel.queryChange()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_queryChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_queryChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_queryChange(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_queryChange, doc_QSqlRelationalTableModel_queryChange);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setLastError, "QSqlRelationalTableModel.setLastError(QSqlError)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setLastError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setLastError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QSqlError, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setLastError(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setLastError, doc_QSqlRelationalTableModel_setLastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_deleteRowFromTable, "QSqlRelationalTableModel.deleteRowFromTable(int) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_deleteRowFromTable(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_deleteRowFromTable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_deleteRowFromTable(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_deleteRowFromTable, doc_QSqlRelationalTableModel_deleteRowFromTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setPrimaryKey, "QSqlRelationalTableModel.setPrimaryKey(QSqlIndex)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setPrimaryKey(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setPrimaryKey(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlIndex* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QSqlIndex, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setPrimaryKey(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setPrimaryKey, doc_QSqlRelationalTableModel_setPrimaryKey);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setQuery, "QSqlRelationalTableModel.setQuery(QSqlQuery)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QSqlQuery, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setQuery(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setQuery, doc_QSqlRelationalTableModel_setQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_indexInQuery, "QSqlRelationalTableModel.indexInQuery(QModelIndex) -> QModelIndex");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_indexInQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_indexInQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            QModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QModelIndex(sipCpp->sipProtect_indexInQuery(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_indexInQuery, doc_QSqlRelationalTableModel_indexInQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_data, "QSqlRelationalTableModel.data(QModelIndex, int role=Qt.DisplayRole) -> object");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_data(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_data(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex* a0;
        int a1 = Qt::DisplayRole;
        const QSqlRelationalTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|i", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant((sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::data(*a0,a1) : sipCpp->data(*a0,a1)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_data, doc_QSqlRelationalTableModel_data);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setData, "QSqlRelationalTableModel.setData(QModelIndex, object, int role=Qt.EditRole) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex* a0;
        const QVariant* a1;
        int a1State = 0;
        int a2 = Qt::EditRole;
        QSqlRelationalTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9J1|i", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QModelIndex, &a0, sipType_QVariant,&a1, &a1State, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::setData(*a0,*a1,a2) : sipCpp->setData(*a0,*a1,a2));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setData, doc_QSqlRelationalTableModel_setData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_clear, "QSqlRelationalTableModel.clear()");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_clear(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_clear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::clear() : sipCpp->clear());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_clear, doc_QSqlRelationalTableModel_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_select, "QSqlRelationalTableModel.select() -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_select(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_select(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::select() : sipCpp->select());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_select, doc_QSqlRelationalTableModel_select);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setTable, "QSqlRelationalTableModel.setTable(str)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setTable(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setTable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::setTable(*a0) : sipCpp->setTable(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setTable, doc_QSqlRelationalTableModel_setTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setRelation, "QSqlRelationalTableModel.setRelation(int, QSqlRelation)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setRelation(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setRelation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        const QSqlRelation* a1;
        QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0, sipType_QSqlRelation, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::setRelation(a0,*a1) : sipCpp->setRelation(a0,*a1));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setRelation, doc_QSqlRelationalTableModel_setRelation);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_relation, "QSqlRelationalTableModel.relation(int) -> QSqlRelation");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_relation(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_relation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0))
        {
            QSqlRelation*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlRelation(sipCpp->relation(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlRelation,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_relation, doc_QSqlRelationalTableModel_relation);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_relationModel, "QSqlRelationalTableModel.relationModel(int) -> QSqlTableModel");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_relationModel(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_relationModel(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        const QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0))
        {
            QSqlTableModel*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::relationModel(a0) : sipCpp->relationModel(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QSqlTableModel,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_relationModel, doc_QSqlRelationalTableModel_relationModel);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_revertRow, "QSqlRelationalTableModel.revertRow(int)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_revertRow(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_revertRow(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::revertRow(a0) : sipCpp->revertRow(a0));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_revertRow, doc_QSqlRelationalTableModel_revertRow);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_removeColumns, "QSqlRelationalTableModel.removeColumns(int, int, QModelIndex parent=QModelIndex()) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_removeColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_removeColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        const QModelIndex& a2def = QModelIndex();
        const QModelIndex* a2 = &a2def;
        QSqlRelationalTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|J9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlRelationalTableModel::removeColumns(a0,a1,*a2) : sipCpp->removeColumns(a0,a1,*a2));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_removeColumns, doc_QSqlRelationalTableModel_removeColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_selectStatement, "QSqlRelationalTableModel.selectStatement() -> str");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_selectStatement(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_selectStatement(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtectVirt_selectStatement(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_selectStatement, doc_QSqlRelationalTableModel_selectStatement);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_updateRowInTable, "QSqlRelationalTableModel.updateRowInTable(int, QSqlRecord) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_updateRowInTable(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_updateRowInTable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        const QSqlRecord* a1;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiJ9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, &a0, sipType_QSqlRecord, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_updateRowInTable(sipSelfWasArg,a0,*a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_updateRowInTable, doc_QSqlRelationalTableModel_updateRowInTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_orderByClause, "QSqlRelationalTableModel.orderByClause() -> str");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_orderByClause(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_orderByClause(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtectVirt_orderByClause(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_orderByClause, doc_QSqlRelationalTableModel_orderByClause);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_insertRowIntoTable, "QSqlRelationalTableModel.insertRowIntoTable(QSqlRecord) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_insertRowIntoTable(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_insertRowIntoTable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlRecord* a0;
        sipQSqlRelationalTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QSqlRecord, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_insertRowIntoTable(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_insertRowIntoTable, doc_QSqlRelationalTableModel_insertRowIntoTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalTableModel_setJoinMode, "QSqlRelationalTableModel.setJoinMode(QSqlRelationalTableModel.JoinMode)");

extern "C" {static PyObject *meth_QSqlRelationalTableModel_setJoinMode(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalTableModel_setJoinMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlRelationalTableModel::JoinMode a0;
        QSqlRelationalTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlRelationalTableModel, &sipCpp, sipType_QSqlRelationalTableModel_JoinMode, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setJoinMode(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalTableModel, sipName_setJoinMode, doc_QSqlRelationalTableModel_setJoinMode);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlRelationalTableModel(void *, const sipTypeDef *);}
static void *cast_QSqlRelationalTableModel(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSqlRelationalTableModel)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QSqlTableModel)->ctd_cast((QSqlTableModel *)(QSqlRelationalTableModel *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlRelationalTableModel(void *, int);}
static void release_QSqlRelationalTableModel(void *sipCppV,int)
{
    QSqlRelationalTableModel *sipCpp = reinterpret_cast<QSqlRelationalTableModel *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSqlRelationalTableModel(sipSimpleWrapper *);}
static void dealloc_QSqlRelationalTableModel(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlRelationalTableModel *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlRelationalTableModel(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlRelationalTableModel(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlRelationalTableModel(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQSqlRelationalTableModel *sipCpp = 0;

    {
        QObject* a0 = 0;
        QSqlDatabase a1def = QSqlDatabase();
        QSqlDatabase* a1 = &a1def;

        static const char *sipKwdList[] = {
            sipName_parent,
            sipName_db,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JHJ9", sipType_QObject, &a0, sipOwner, sipType_QSqlDatabase, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlRelationalTableModel(a0,*a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSqlRelationalTableModel[] = {{27, 255, 1}};


static PyMethodDef methods_QSqlRelationalTableModel[] = {
    {SIP_MLNAME_CAST(sipName_beginInsertColumns), (PyCFunction)meth_QSqlRelationalTableModel_beginInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginInsertRows), (PyCFunction)meth_QSqlRelationalTableModel_beginInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveColumns), (PyCFunction)meth_QSqlRelationalTableModel_beginMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveRows), (PyCFunction)meth_QSqlRelationalTableModel_beginMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveColumns), (PyCFunction)meth_QSqlRelationalTableModel_beginRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveRows), (PyCFunction)meth_QSqlRelationalTableModel_beginRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginResetModel), (PyCFunction)meth_QSqlRelationalTableModel_beginResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_changePersistentIndex), (PyCFunction)meth_QSqlRelationalTableModel_changePersistentIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_changePersistentIndexList), (PyCFunction)meth_QSqlRelationalTableModel_changePersistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QSqlRelationalTableModel_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_clear), meth_QSqlRelationalTableModel_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_clear)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QSqlRelationalTableModel_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createIndex), (PyCFunction)meth_QSqlRelationalTableModel_createIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QSqlRelationalTableModel_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_data), (PyCFunction)meth_QSqlRelationalTableModel_data, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_data)},
    {SIP_MLNAME_CAST(sipName_decodeData), (PyCFunction)meth_QSqlRelationalTableModel_decodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_deleteRowFromTable), (PyCFunction)meth_QSqlRelationalTableModel_deleteRowFromTable, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QSqlRelationalTableModel_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_encodeData), (PyCFunction)meth_QSqlRelationalTableModel_encodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertColumns), (PyCFunction)meth_QSqlRelationalTableModel_endInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertRows), (PyCFunction)meth_QSqlRelationalTableModel_endInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveColumns), (PyCFunction)meth_QSqlRelationalTableModel_endMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveRows), (PyCFunction)meth_QSqlRelationalTableModel_endMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveColumns), (PyCFunction)meth_QSqlRelationalTableModel_endRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveRows), (PyCFunction)meth_QSqlRelationalTableModel_endRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endResetModel), (PyCFunction)meth_QSqlRelationalTableModel_endResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_indexInQuery), (PyCFunction)meth_QSqlRelationalTableModel_indexInQuery, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_insertRowIntoTable), (PyCFunction)meth_QSqlRelationalTableModel_insertRowIntoTable, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_insertRowIntoTable)},
    {SIP_MLNAME_CAST(sipName_orderByClause), (PyCFunction)meth_QSqlRelationalTableModel_orderByClause, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_orderByClause)},
    {SIP_MLNAME_CAST(sipName_persistentIndexList), (PyCFunction)meth_QSqlRelationalTableModel_persistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_queryChange), (PyCFunction)meth_QSqlRelationalTableModel_queryChange, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QSqlRelationalTableModel_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_relation), meth_QSqlRelationalTableModel_relation, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_relation)},
    {SIP_MLNAME_CAST(sipName_relationModel), meth_QSqlRelationalTableModel_relationModel, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_relationModel)},
    {SIP_MLNAME_CAST(sipName_removeColumns), (PyCFunction)meth_QSqlRelationalTableModel_removeColumns, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_removeColumns)},
    {SIP_MLNAME_CAST(sipName_reset), (PyCFunction)meth_QSqlRelationalTableModel_reset, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_resetInternalData), (PyCFunction)meth_QSqlRelationalTableModel_resetInternalData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_revertRow), meth_QSqlRelationalTableModel_revertRow, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_revertRow)},
    {SIP_MLNAME_CAST(sipName_select), meth_QSqlRelationalTableModel_select, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_select)},
    {SIP_MLNAME_CAST(sipName_selectStatement), (PyCFunction)meth_QSqlRelationalTableModel_selectStatement, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_selectStatement)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QSqlRelationalTableModel_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QSqlRelationalTableModel_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setData), (PyCFunction)meth_QSqlRelationalTableModel_setData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_setData)},
    {SIP_MLNAME_CAST(sipName_setJoinMode), meth_QSqlRelationalTableModel_setJoinMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_setJoinMode)},
    {SIP_MLNAME_CAST(sipName_setLastError), (PyCFunction)meth_QSqlRelationalTableModel_setLastError, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setPrimaryKey), (PyCFunction)meth_QSqlRelationalTableModel_setPrimaryKey, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setQuery), (PyCFunction)meth_QSqlRelationalTableModel_setQuery, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setRelation), meth_QSqlRelationalTableModel_setRelation, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_setRelation)},
    {SIP_MLNAME_CAST(sipName_setRoleNames), (PyCFunction)meth_QSqlRelationalTableModel_setRoleNames, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setTable), meth_QSqlRelationalTableModel_setTable, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_setTable)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QSqlRelationalTableModel_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateRowInTable), (PyCFunction)meth_QSqlRelationalTableModel_updateRowInTable, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlRelationalTableModel_updateRowInTable)}
};

static sipEnumMemberDef enummembers_QSqlRelationalTableModel[] = {
    {sipName_InnerJoin, static_cast<int>(QSqlRelationalTableModel::InnerJoin), 24},
    {sipName_LeftJoin, static_cast<int>(QSqlRelationalTableModel::LeftJoin), 24},
};

PyDoc_STRVAR(doc_QSqlRelationalTableModel, "\1QSqlRelationalTableModel(QObject parent=None, QSqlDatabase db=QSqlDatabase())");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlRelationalTableModel = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QSqlRelationalTableModel,
        {0}
    },
    {
        sipNameNr_QSqlRelationalTableModel,
        {0, 0, 1},
        52, methods_QSqlRelationalTableModel,
        2, enummembers_QSqlRelationalTableModel,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlRelationalTableModel,
    -1,
    -1,
    supers_QSqlRelationalTableModel,
    0,
    init_type_QSqlRelationalTableModel,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlRelationalTableModel,
    0,
    0,
    0,
    release_QSqlRelationalTableModel,
    cast_QSqlRelationalTableModel,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QSqlRelationalTableModel::staticMetaObject,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqltablemodel.sip"
#include <qsqltablemodel.h>
#line 6575 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 6579 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 6582 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 6585 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlquery.sip"
#include <qsqlquery.h>
#line 6588 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlindex.sip"
#include <qsqlindex.h>
#line 6591 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6594 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 6597 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6600 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 6603 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6606 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 6609 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qmimedata.sip"
#include <qmimedata.h>
#line 6612 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 139 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qhash.sip"
#include <qhash.h>
#line 6615 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 6618 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6621 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 6624 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qdatastream.sip"
#include <qdatastream.h>
#line 6627 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 6630 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 6633 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 6636 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 139 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qmap.sip"
#include <qmap.h>
#line 6639 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 6642 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6645 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6648 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 6651 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 6654 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 6657 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 6660 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 6663 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 6666 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlTableModel : public QSqlTableModel
{
public:
    sipQSqlTableModel(QObject*,QSqlDatabase);
    virtual ~sipQSqlTableModel();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtect_resetInternalData();
    void sipProtect_encodeData(const QModelIndexList&,QDataStream&) const;
    bool sipProtect_decodeData(int,int,const QModelIndex&,QDataStream&);
    void sipProtect_beginInsertRows(const QModelIndex&,int,int);
    void sipProtect_endInsertRows();
    void sipProtect_beginRemoveRows(const QModelIndex&,int,int);
    void sipProtect_endRemoveRows();
    void sipProtect_beginInsertColumns(const QModelIndex&,int,int);
    void sipProtect_endInsertColumns();
    void sipProtect_beginRemoveColumns(const QModelIndex&,int,int);
    void sipProtect_endRemoveColumns();
    QModelIndexList sipProtect_persistentIndexList() const;
    void sipProtect_reset();
    void sipProtect_changePersistentIndex(const QModelIndex&,const QModelIndex&);
    void sipProtect_changePersistentIndexList(const QModelIndexList&,const QModelIndexList&);
    QModelIndex sipProtect_createIndex(int,int,void*) const;
    bool sipProtect_beginMoveRows(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveRows();
    bool sipProtect_beginMoveColumns(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveColumns();
    void sipProtect_beginResetModel();
    void sipProtect_endResetModel();
    void sipProtect_setRoleNames(const QHash<int,QByteArray>&);
    void sipProtectVirt_queryChange(bool);
    void sipProtect_setLastError(const QSqlError&);
    bool sipProtectVirt_updateRowInTable(bool,int,const QSqlRecord&);
    bool sipProtectVirt_insertRowIntoTable(bool,const QSqlRecord&);
    bool sipProtectVirt_deleteRowFromTable(bool,int);
    QString sipProtectVirt_orderByClause(bool) const;
    QString sipProtectVirt_selectStatement(bool) const;
    void sipProtect_setPrimaryKey(const QSqlIndex&);
    void sipProtect_setQuery(const QSqlQuery&);
    QModelIndex sipProtect_indexInQuery(const QModelIndex&) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    QSize span(const QModelIndex&) const;
    QModelIndexList match(const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags) const;
    QModelIndex buddy(const QModelIndex&) const;
    Qt::DropActions supportedDropActions() const;
    QMimeData* mimeData(const QModelIndexList&) const;
    QStringList mimeTypes() const;
    bool setItemData(const QModelIndex&,const QMap<int,QVariant>&);
    QMap<int,QVariant> itemData(const QModelIndex&) const;
    bool dropMimeData(const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);
    QModelIndex index(int,int,const QModelIndex&) const;
    void queryChange();
    bool canFetchMore(const QModelIndex&) const;
    void fetchMore(const QModelIndex&);
    bool insertColumns(int,int,const QModelIndex&);
    bool setHeaderData(int,Qt::Orientation,const QVariant&,int);
    int columnCount(const QModelIndex&) const;
    QString selectStatement() const;
    QString orderByClause() const;
    bool deleteRowFromTable(int);
    bool insertRowIntoTable(const QSqlRecord&);
    bool updateRowInTable(int,const QSqlRecord&);
    void revert();
    bool submit();
    void revertRow(int);
    bool insertRows(int,int,const QModelIndex&);
    bool removeRows(int,int,const QModelIndex&);
    bool removeColumns(int,int,const QModelIndex&);
    int rowCount(const QModelIndex&) const;
    void setFilter(const QString&);
    void setSort(int,Qt::SortOrder);
    void sort(int,Qt::SortOrder);
    void setEditStrategy(QSqlTableModel::EditStrategy);
    void clear();
    QVariant headerData(int,Qt::Orientation,int) const;
    bool setData(const QModelIndex&,const QVariant&,int);
    QVariant data(const QModelIndex&,int) const;
    Qt::ItemFlags flags(const QModelIndex&) const;
    void setTable(const QString&);
    bool select();

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlTableModel(const sipQSqlTableModel &);
    sipQSqlTableModel &operator = (const sipQSqlTableModel &);

    char sipPyMethods[46];
};

sipQSqlTableModel::sipQSqlTableModel(QObject*a0,QSqlDatabase a1): QSqlTableModel(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlTableModel::~sipQSqlTableModel()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQSqlTableModel::metaObject() const
{
    return sip_QtSql_qt_metaobject(sipPySelf,sipType_QSqlTableModel);
}

int sipQSqlTableModel::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QSqlTableModel::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtSql_qt_metacall(sipPySelf,sipType_QSqlTableModel,_c,_id,_a);

    return _id;
}

void *sipQSqlTableModel::qt_metacast(const char *_clname)
{
    return (sip_QtSql_qt_metacast(sipPySelf, sipType_QSqlTableModel, _clname)) ? this : QSqlTableModel::qt_metacast(_clname);
}

void sipQSqlTableModel::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QSqlTableModel::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QSqlTableModel::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QSqlTableModel::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtSql_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QSqlTableModel::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtSql_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QSqlTableModel::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtSql_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlTableModel::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QSqlTableModel::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtSql_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

bool sipQSqlTableModel::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QSqlTableModel::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtSql_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QSize sipQSqlTableModel::span(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[7]),sipPySelf,NULL,sipName_span);

    if (!sipMeth)
        return QSqlTableModel::span(a0);

    typedef QSize (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_47)(sipModuleAPI_QtSql_QtCore->em_virthandlers[47]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QModelIndexList sipQSqlTableModel::match(const QModelIndex& a0,int a1,const QVariant& a2,int a3,Qt::MatchFlags a4) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,NULL,sipName_match);

    if (!sipMeth)
        return QSqlTableModel::match(a0,a1,a2,a3,a4);

    typedef QList<QModelIndex> (*sipVH_QtCore_48)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags);

    return ((sipVH_QtCore_48)(sipModuleAPI_QtSql_QtCore->em_virthandlers[48]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipQSqlTableModel::buddy(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,NULL,sipName_buddy);

    if (!sipMeth)
        return QSqlTableModel::buddy(a0);

    typedef QModelIndex (*sipVH_QtCore_44)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_44)(sipModuleAPI_QtSql_QtCore->em_virthandlers[44]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

Qt::DropActions sipQSqlTableModel::supportedDropActions() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,NULL,sipName_supportedDropActions);

    if (!sipMeth)
        return QSqlTableModel::supportedDropActions();

    typedef Qt::DropActions (*sipVH_QtCore_53)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_53)(sipModuleAPI_QtSql_QtCore->em_virthandlers[53]))(sipGILState, 0, sipPySelf, sipMeth);
}

QMimeData* sipQSqlTableModel::mimeData(const QModelIndexList& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,NULL,sipName_mimeData);

    if (!sipMeth)
        return QSqlTableModel::mimeData(a0);

    typedef QMimeData* (*sipVH_QtCore_54)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QList<QModelIndex>&);

    return ((sipVH_QtCore_54)(sipModuleAPI_QtSql_QtCore->em_virthandlers[54]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QStringList sipQSqlTableModel::mimeTypes() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,NULL,sipName_mimeTypes);

    if (!sipMeth)
        return QSqlTableModel::mimeTypes();

    typedef QStringList (*sipVH_QtCore_27)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_27)(sipModuleAPI_QtSql_QtCore->em_virthandlers[27]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlTableModel::setItemData(const QModelIndex& a0,const QMap<int,QVariant>& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[13],sipPySelf,NULL,sipName_setItemData);

    if (!sipMeth)
        return QSqlTableModel::setItemData(a0,a1);

    typedef bool (*sipVH_QtCore_55)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,const QMap<int,QVariant>&);

    return ((sipVH_QtCore_55)(sipModuleAPI_QtSql_QtCore->em_virthandlers[55]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QMap<int,QVariant> sipQSqlTableModel::itemData(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[14]),sipPySelf,NULL,sipName_itemData);

    if (!sipMeth)
        return QSqlTableModel::itemData(a0);

    typedef QMap<int,QVariant> (*sipVH_QtCore_56)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_56)(sipModuleAPI_QtSql_QtCore->em_virthandlers[56]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlTableModel::dropMimeData(const QMimeData*a0,Qt::DropAction a1,int a2,int a3,const QModelIndex& a4)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,NULL,sipName_dropMimeData);

    if (!sipMeth)
        return QSqlTableModel::dropMimeData(a0,a1,a2,a3,a4);

    typedef bool (*sipVH_QtCore_45)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);

    return ((sipVH_QtCore_45)(sipModuleAPI_QtSql_QtCore->em_virthandlers[45]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipQSqlTableModel::index(int a0,int a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[16]),sipPySelf,NULL,sipName_index);

    if (!sipMeth)
        return QSqlTableModel::index(a0,a1,a2);

    typedef QModelIndex (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_46)(sipModuleAPI_QtSql_QtCore->em_virthandlers[46]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlTableModel::queryChange()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[17],sipPySelf,NULL,sipName_queryChange);

    if (!sipMeth)
    {
        QSqlTableModel::queryChange();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlTableModel::canFetchMore(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[18]),sipPySelf,NULL,sipName_canFetchMore);

    if (!sipMeth)
        return QSqlTableModel::canFetchMore(a0);

    typedef bool (*sipVH_QtCore_42)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_42)(sipModuleAPI_QtSql_QtCore->em_virthandlers[42]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::fetchMore(const QModelIndex& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[19],sipPySelf,NULL,sipName_fetchMore);

    if (!sipMeth)
    {
        QSqlTableModel::fetchMore(a0);
        return;
    }

    typedef void (*sipVH_QtCore_51)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    ((sipVH_QtCore_51)(sipModuleAPI_QtSql_QtCore->em_virthandlers[51]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlTableModel::insertColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[20],sipPySelf,NULL,sipName_insertColumns);

    if (!sipMeth)
        return QSqlTableModel::insertColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlTableModel::setHeaderData(int a0,Qt::Orientation a1,const QVariant& a2,int a3)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,NULL,sipName_setHeaderData);

    if (!sipMeth)
        return QSqlTableModel::setHeaderData(a0,a1,a2,a3);

    typedef bool (*sipVH_QtCore_57)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,const QVariant&,int);

    return ((sipVH_QtCore_57)(sipModuleAPI_QtSql_QtCore->em_virthandlers[57]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

int sipQSqlTableModel::columnCount(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[22]),sipPySelf,NULL,sipName_columnCount);

    if (!sipMeth)
        return QSqlTableModel::columnCount(a0);

    typedef int (*sipVH_QtCore_43)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_43)(sipModuleAPI_QtSql_QtCore->em_virthandlers[43]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QString sipQSqlTableModel::selectStatement() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[23]),sipPySelf,NULL,sipName_selectStatement);

    if (!sipMeth)
        return QSqlTableModel::selectStatement();

    typedef QString (*sipVH_QtCore_62)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_62)(sipModuleAPI_QtSql_QtCore->em_virthandlers[62]))(sipGILState, 0, sipPySelf, sipMeth);
}

QString sipQSqlTableModel::orderByClause() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[24]),sipPySelf,NULL,sipName_orderByClause);

    if (!sipMeth)
        return QSqlTableModel::orderByClause();

    typedef QString (*sipVH_QtCore_62)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_62)(sipModuleAPI_QtSql_QtCore->em_virthandlers[62]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlTableModel::deleteRowFromTable(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[25],sipPySelf,NULL,sipName_deleteRowFromTable);

    if (!sipMeth)
        return QSqlTableModel::deleteRowFromTable(a0);

    typedef bool (*sipVH_QtCore_23)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return ((sipVH_QtCore_23)(sipModuleAPI_QtSql_QtCore->em_virthandlers[23]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlTableModel::insertRowIntoTable(const QSqlRecord& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[26],sipPySelf,NULL,sipName_insertRowIntoTable);

    if (!sipMeth)
        return QSqlTableModel::insertRowIntoTable(a0);

    extern bool sipVH_QtSql_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QSqlRecord&);

    return sipVH_QtSql_0(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlTableModel::updateRowInTable(int a0,const QSqlRecord& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[27],sipPySelf,NULL,sipName_updateRowInTable);

    if (!sipMeth)
        return QSqlTableModel::updateRowInTable(a0,a1);

    extern bool sipVH_QtSql_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,const QSqlRecord&);

    return sipVH_QtSql_1(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlTableModel::revert()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[28],sipPySelf,NULL,sipName_revert);

    if (!sipMeth)
    {
        QSqlTableModel::revert();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlTableModel::submit()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[29],sipPySelf,NULL,sipName_submit);

    if (!sipMeth)
        return QSqlTableModel::submit();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQSqlTableModel::revertRow(int a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[30],sipPySelf,NULL,sipName_revertRow);

    if (!sipMeth)
    {
        QSqlTableModel::revertRow(a0);
        return;
    }

    typedef void (*sipVH_QtCore_4)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    ((sipVH_QtCore_4)(sipModuleAPI_QtSql_QtCore->em_virthandlers[4]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlTableModel::insertRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[31],sipPySelf,NULL,sipName_insertRows);

    if (!sipMeth)
        return QSqlTableModel::insertRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlTableModel::removeRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[32],sipPySelf,NULL,sipName_removeRows);

    if (!sipMeth)
        return QSqlTableModel::removeRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlTableModel::removeColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[33],sipPySelf,NULL,sipName_removeColumns);

    if (!sipMeth)
        return QSqlTableModel::removeColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

int sipQSqlTableModel::rowCount(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[34]),sipPySelf,NULL,sipName_rowCount);

    if (!sipMeth)
        return QSqlTableModel::rowCount(a0);

    typedef int (*sipVH_QtCore_43)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_43)(sipModuleAPI_QtSql_QtCore->em_virthandlers[43]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::setFilter(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[35],sipPySelf,NULL,sipName_setFilter);

    if (!sipMeth)
    {
        QSqlTableModel::setFilter(a0);
        return;
    }

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtSql_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::setSort(int a0,Qt::SortOrder a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[36],sipPySelf,NULL,sipName_setSort);

    if (!sipMeth)
    {
        QSqlTableModel::setSort(a0,a1);
        return;
    }

    typedef void (*sipVH_QtCore_49)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::SortOrder);

    ((sipVH_QtCore_49)(sipModuleAPI_QtSql_QtCore->em_virthandlers[49]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlTableModel::sort(int a0,Qt::SortOrder a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[37],sipPySelf,NULL,sipName_sort);

    if (!sipMeth)
    {
        QSqlTableModel::sort(a0,a1);
        return;
    }

    typedef void (*sipVH_QtCore_49)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::SortOrder);

    ((sipVH_QtCore_49)(sipModuleAPI_QtSql_QtCore->em_virthandlers[49]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlTableModel::setEditStrategy(QSqlTableModel::EditStrategy a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[38],sipPySelf,NULL,sipName_setEditStrategy);

    if (!sipMeth)
    {
        QSqlTableModel::setEditStrategy(a0);
        return;
    }

    extern void sipVH_QtSql_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QSqlTableModel::EditStrategy);

    sipVH_QtSql_2(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::clear()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[39],sipPySelf,NULL,sipName_clear);

    if (!sipMeth)
    {
        QSqlTableModel::clear();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

QVariant sipQSqlTableModel::headerData(int a0,Qt::Orientation a1,int a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[40]),sipPySelf,NULL,sipName_headerData);

    if (!sipMeth)
        return QSqlTableModel::headerData(a0,a1,a2);

    typedef QVariant (*sipVH_QtCore_58)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,int);

    return ((sipVH_QtCore_58)(sipModuleAPI_QtSql_QtCore->em_virthandlers[58]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlTableModel::setData(const QModelIndex& a0,const QVariant& a1,int a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[41],sipPySelf,NULL,sipName_setData);

    if (!sipMeth)
        return QSqlTableModel::setData(a0,a1,a2);

    typedef bool (*sipVH_QtCore_59)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,const QVariant&,int);

    return ((sipVH_QtCore_59)(sipModuleAPI_QtSql_QtCore->em_virthandlers[59]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

QVariant sipQSqlTableModel::data(const QModelIndex& a0,int a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[42]),sipPySelf,NULL,sipName_data);

    if (!sipMeth)
        return QSqlTableModel::data(a0,a1);

    typedef QVariant (*sipVH_QtCore_60)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int);

    return ((sipVH_QtCore_60)(sipModuleAPI_QtSql_QtCore->em_virthandlers[60]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

Qt::ItemFlags sipQSqlTableModel::flags(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[43]),sipPySelf,NULL,sipName_flags);

    if (!sipMeth)
        return QSqlTableModel::flags(a0);

    typedef Qt::ItemFlags (*sipVH_QtCore_50)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_50)(sipModuleAPI_QtSql_QtCore->em_virthandlers[50]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlTableModel::setTable(const QString& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[44],sipPySelf,NULL,sipName_setTable);

    if (!sipMeth)
    {
        QSqlTableModel::setTable(a0);
        return;
    }

    typedef void (*sipVH_QtCore_33)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    ((sipVH_QtCore_33)(sipModuleAPI_QtSql_QtCore->em_virthandlers[33]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlTableModel::select()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[45],sipPySelf,NULL,sipName_select);

    if (!sipMeth)
        return QSqlTableModel::select();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

QObject* sipQSqlTableModel::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQSqlTableModel::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQSqlTableModel::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQSqlTableModel::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQSqlTableModel::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQSqlTableModel::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQSqlTableModel::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQSqlTableModel::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

void sipQSqlTableModel::sipProtect_resetInternalData()
{
    QAbstractItemModel::resetInternalData();
}

void sipQSqlTableModel::sipProtect_encodeData(const QModelIndexList& a0,QDataStream& a1) const
{
    QAbstractItemModel::encodeData(a0,a1);
}

bool sipQSqlTableModel::sipProtect_decodeData(int a0,int a1,const QModelIndex& a2,QDataStream& a3)
{
    return QAbstractItemModel::decodeData(a0,a1,a2,a3);
}

void sipQSqlTableModel::sipProtect_beginInsertRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertRows(a0,a1,a2);
}

void sipQSqlTableModel::sipProtect_endInsertRows()
{
    QAbstractItemModel::endInsertRows();
}

void sipQSqlTableModel::sipProtect_beginRemoveRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveRows(a0,a1,a2);
}

void sipQSqlTableModel::sipProtect_endRemoveRows()
{
    QAbstractItemModel::endRemoveRows();
}

void sipQSqlTableModel::sipProtect_beginInsertColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertColumns(a0,a1,a2);
}

void sipQSqlTableModel::sipProtect_endInsertColumns()
{
    QAbstractItemModel::endInsertColumns();
}

void sipQSqlTableModel::sipProtect_beginRemoveColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveColumns(a0,a1,a2);
}

void sipQSqlTableModel::sipProtect_endRemoveColumns()
{
    QAbstractItemModel::endRemoveColumns();
}

QModelIndexList sipQSqlTableModel::sipProtect_persistentIndexList() const
{
    return QAbstractItemModel::persistentIndexList();
}

void sipQSqlTableModel::sipProtect_reset()
{
    QAbstractItemModel::reset();
}

void sipQSqlTableModel::sipProtect_changePersistentIndex(const QModelIndex& a0,const QModelIndex& a1)
{
    QAbstractItemModel::changePersistentIndex(a0,a1);
}

void sipQSqlTableModel::sipProtect_changePersistentIndexList(const QModelIndexList& a0,const QModelIndexList& a1)
{
    QAbstractItemModel::changePersistentIndexList(a0,a1);
}

QModelIndex sipQSqlTableModel::sipProtect_createIndex(int a0,int a1,void*a2) const
{
    return QAbstractItemModel::createIndex(a0,a1,a2);
}

bool sipQSqlTableModel::sipProtect_beginMoveRows(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveRows(a0,a1,a2,a3,a4);
}

void sipQSqlTableModel::sipProtect_endMoveRows()
{
    QAbstractItemModel::endMoveRows();
}

bool sipQSqlTableModel::sipProtect_beginMoveColumns(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveColumns(a0,a1,a2,a3,a4);
}

void sipQSqlTableModel::sipProtect_endMoveColumns()
{
    QAbstractItemModel::endMoveColumns();
}

void sipQSqlTableModel::sipProtect_beginResetModel()
{
    QAbstractItemModel::beginResetModel();
}

void sipQSqlTableModel::sipProtect_endResetModel()
{
    QAbstractItemModel::endResetModel();
}

void sipQSqlTableModel::sipProtect_setRoleNames(const QHash<int,QByteArray>& a0)
{
    QAbstractItemModel::setRoleNames(a0);
}

void sipQSqlTableModel::sipProtectVirt_queryChange(bool sipSelfWasArg)
{
    (sipSelfWasArg ? QSqlQueryModel::queryChange() : queryChange());
}

void sipQSqlTableModel::sipProtect_setLastError(const QSqlError& a0)
{
    QSqlQueryModel::setLastError(a0);
}

bool sipQSqlTableModel::sipProtectVirt_updateRowInTable(bool sipSelfWasArg,int a0,const QSqlRecord& a1)
{
    return (sipSelfWasArg ? QSqlTableModel::updateRowInTable(a0,a1) : updateRowInTable(a0,a1));
}

bool sipQSqlTableModel::sipProtectVirt_insertRowIntoTable(bool sipSelfWasArg,const QSqlRecord& a0)
{
    return (sipSelfWasArg ? QSqlTableModel::insertRowIntoTable(a0) : insertRowIntoTable(a0));
}

bool sipQSqlTableModel::sipProtectVirt_deleteRowFromTable(bool sipSelfWasArg,int a0)
{
    return (sipSelfWasArg ? QSqlTableModel::deleteRowFromTable(a0) : deleteRowFromTable(a0));
}

QString sipQSqlTableModel::sipProtectVirt_orderByClause(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? QSqlTableModel::orderByClause() : orderByClause());
}

QString sipQSqlTableModel::sipProtectVirt_selectStatement(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ? QSqlTableModel::selectStatement() : selectStatement());
}

void sipQSqlTableModel::sipProtect_setPrimaryKey(const QSqlIndex& a0)
{
    QSqlTableModel::setPrimaryKey(a0);
}

void sipQSqlTableModel::sipProtect_setQuery(const QSqlQuery& a0)
{
    QSqlTableModel::setQuery(a0);
}

QModelIndex sipQSqlTableModel::sipProtect_indexInQuery(const QModelIndex& a0) const
{
    return QSqlTableModel::indexInQuery(a0);
}


PyDoc_STRVAR(doc_QSqlTableModel_sender, "QSqlTableModel.sender() -> QObject");

extern "C" {static PyObject *meth_QSqlTableModel_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QObject*sipRes = 0;

#line 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (helper)
            sipRes = helper(sipRes);
#line 7795 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_sender, doc_QSqlTableModel_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_receivers, "QSqlTableModel.receivers(SIGNAL()) -> int");

extern "C" {static PyObject *meth_QSqlTableModel_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        char* a0;
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 7840 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_receivers, doc_QSqlTableModel_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_timerEvent, "QSqlTableModel.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QSqlTableModel_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_timerEvent, doc_QSqlTableModel_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_childEvent, "QSqlTableModel.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QSqlTableModel_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_childEvent, doc_QSqlTableModel_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_customEvent, "QSqlTableModel.customEvent(QEvent)");

extern "C" {static PyObject *meth_QSqlTableModel_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_customEvent, doc_QSqlTableModel_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_connectNotify, "QSqlTableModel.connectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlTableModel_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_connectNotify, doc_QSqlTableModel_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_disconnectNotify, "QSqlTableModel.disconnectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlTableModel_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_disconnectNotify, doc_QSqlTableModel_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_senderSignalIndex, "QSqlTableModel.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QSqlTableModel_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_senderSignalIndex, doc_QSqlTableModel_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_resetInternalData, "QSqlTableModel.resetInternalData()");

extern "C" {static PyObject *meth_QSqlTableModel_resetInternalData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_resetInternalData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_resetInternalData();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_resetInternalData, doc_QSqlTableModel_resetInternalData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_encodeData, "QSqlTableModel.encodeData(list-of-QModelIndex, QDataStream)");

extern "C" {static PyObject *meth_QSqlTableModel_encodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_encodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        QDataStream* a1;
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QDataStream, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_encodeData(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_encodeData, doc_QSqlTableModel_encodeData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_decodeData, "QSqlTableModel.decodeData(int, int, QModelIndex, QDataStream) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_decodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_decodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        const QModelIndex* a2;
        QDataStream* a3;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiiJ9J9", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2, sipType_QDataStream, &a3))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_decodeData(a0,a1,*a2,*a3);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_decodeData, doc_QSqlTableModel_decodeData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_beginInsertRows, "QSqlTableModel.beginInsertRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlTableModel_beginInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_beginInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginInsertRows(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_beginInsertRows, doc_QSqlTableModel_beginInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_endInsertRows, "QSqlTableModel.endInsertRows()");

extern "C" {static PyObject *meth_QSqlTableModel_endInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_endInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endInsertRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_endInsertRows, doc_QSqlTableModel_endInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_beginRemoveRows, "QSqlTableModel.beginRemoveRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlTableModel_beginRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_beginRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginRemoveRows(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_beginRemoveRows, doc_QSqlTableModel_beginRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_endRemoveRows, "QSqlTableModel.endRemoveRows()");

extern "C" {static PyObject *meth_QSqlTableModel_endRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_endRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endRemoveRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_endRemoveRows, doc_QSqlTableModel_endRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_beginInsertColumns, "QSqlTableModel.beginInsertColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlTableModel_beginInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_beginInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginInsertColumns(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_beginInsertColumns, doc_QSqlTableModel_beginInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_endInsertColumns, "QSqlTableModel.endInsertColumns()");

extern "C" {static PyObject *meth_QSqlTableModel_endInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_endInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endInsertColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_endInsertColumns, doc_QSqlTableModel_endInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_beginRemoveColumns, "QSqlTableModel.beginRemoveColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlTableModel_beginRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_beginRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginRemoveColumns(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_beginRemoveColumns, doc_QSqlTableModel_beginRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_endRemoveColumns, "QSqlTableModel.endRemoveColumns()");

extern "C" {static PyObject *meth_QSqlTableModel_endRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_endRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endRemoveColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_endRemoveColumns, doc_QSqlTableModel_endRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_persistentIndexList, "QSqlTableModel.persistentIndexList() -> list-of-QModelIndex");

extern "C" {static PyObject *meth_QSqlTableModel_persistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_persistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QModelIndexList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QModelIndexList(sipCpp->sipProtect_persistentIndexList());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_persistentIndexList, doc_QSqlTableModel_persistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_reset, "QSqlTableModel.reset()");

extern "C" {static PyObject *meth_QSqlTableModel_reset(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_reset(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_reset();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_reset, doc_QSqlTableModel_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_changePersistentIndex, "QSqlTableModel.changePersistentIndex(QModelIndex, QModelIndex)");

extern "C" {static PyObject *meth_QSqlTableModel_changePersistentIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_changePersistentIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const QModelIndex* a1;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9J9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, sipType_QModelIndex, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_changePersistentIndex(*a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_changePersistentIndex, doc_QSqlTableModel_changePersistentIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_changePersistentIndexList, "QSqlTableModel.changePersistentIndexList(list-of-QModelIndex, list-of-QModelIndex)");

extern "C" {static PyObject *meth_QSqlTableModel_changePersistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_changePersistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        const QModelIndexList* a1;
        int a1State = 0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QList_0100QModelIndex,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_changePersistentIndexList(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);
            sipReleaseType(const_cast<QModelIndexList *>(a1),sipType_QList_0100QModelIndex,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_changePersistentIndexList, doc_QSqlTableModel_changePersistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_createIndex, "QSqlTableModel.createIndex(int, int, object object=0) -> QModelIndex");

extern "C" {static PyObject *meth_QSqlTableModel_createIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_createIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        PyObject * a2 = 0;
        const sipQSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_object,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|P0", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, &a1, &a2))
        {
            QModelIndex*sipRes = 0;

#line 243 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
        // The Qt API is broken (and won't be fixed as it would break binary
        // compatibility) regarding the internal id of a model index on different
        // architectures (32 vs 64 bits).  We choose to work around the breakage as it
        // is fairly subtle and continues to catch people out.  Instead of letting Qt
        // convert betweed an integer id and a pointer id (the internal format used by
        // Qt) we let Python do it.
        
        void *ptr;
        
        if (a2)
        {
            // Try and convert it to a Python long and fallback to the object's
            // address if it fails.
            ptr = PyLong_AsVoidPtr(a2);
        
            if (PyErr_Occurred())
            {
                PyErr_Clear();
                ptr = a2;
            }
        }
        else
        {
            ptr = 0;
        }
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = new QModelIndex(sipCpp->createIndex(a0, a1, ptr));
        #else
        sipRes = new QModelIndex(sipCpp->sipProtect_createIndex(a0, a1, ptr));
        #endif
#line 8537 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromNewType(sipRes,sipType_QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_createIndex, doc_QSqlTableModel_createIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_beginMoveRows, "QSqlTableModel.beginMoveRows(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_beginMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_beginMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_beginMoveRows(*a0,a1,a2,*a3,a4);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_beginMoveRows, doc_QSqlTableModel_beginMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_endMoveRows, "QSqlTableModel.endMoveRows()");

extern "C" {static PyObject *meth_QSqlTableModel_endMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_endMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endMoveRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_endMoveRows, doc_QSqlTableModel_endMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_beginMoveColumns, "QSqlTableModel.beginMoveColumns(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_beginMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_beginMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_beginMoveColumns(*a0,a1,a2,*a3,a4);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_beginMoveColumns, doc_QSqlTableModel_beginMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_endMoveColumns, "QSqlTableModel.endMoveColumns()");

extern "C" {static PyObject *meth_QSqlTableModel_endMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_endMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endMoveColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_endMoveColumns, doc_QSqlTableModel_endMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_beginResetModel, "QSqlTableModel.beginResetModel()");

extern "C" {static PyObject *meth_QSqlTableModel_beginResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_beginResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginResetModel();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_beginResetModel, doc_QSqlTableModel_beginResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_endResetModel, "QSqlTableModel.endResetModel()");

extern "C" {static PyObject *meth_QSqlTableModel_endResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_endResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endResetModel();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_endResetModel, doc_QSqlTableModel_endResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setRoleNames, "QSqlTableModel.setRoleNames(dict-of-int-QByteArray)");

extern "C" {static PyObject *meth_QSqlTableModel_setRoleNames(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setRoleNames(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QHash<int,QByteArray>* a0;
        int a0State = 0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QHash_1800_0100QByteArray,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setRoleNames(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QHash<int,QByteArray> *>(a0),sipType_QHash_1800_0100QByteArray,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setRoleNames, doc_QSqlTableModel_setRoleNames);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_queryChange, "QSqlTableModel.queryChange()");

extern "C" {static PyObject *meth_QSqlTableModel_queryChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_queryChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_queryChange(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_queryChange, doc_QSqlTableModel_queryChange);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setLastError, "QSqlTableModel.setLastError(QSqlError)");

extern "C" {static PyObject *meth_QSqlTableModel_setLastError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setLastError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QSqlError, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setLastError(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setLastError, doc_QSqlTableModel_setLastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_select, "QSqlTableModel.select() -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_select(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_select(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlTableModel::select() : sipCpp->select());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_select, doc_QSqlTableModel_select);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setTable, "QSqlTableModel.setTable(str)");

extern "C" {static PyObject *meth_QSqlTableModel_setTable(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setTable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::setTable(*a0) : sipCpp->setTable(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setTable, doc_QSqlTableModel_setTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_tableName, "QSqlTableModel.tableName() -> str");

extern "C" {static PyObject *meth_QSqlTableModel_tableName(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_tableName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->tableName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_tableName, doc_QSqlTableModel_tableName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_flags, "QSqlTableModel.flags(QModelIndex) -> Qt.ItemFlags");

extern "C" {static PyObject *meth_QSqlTableModel_flags(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_flags(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex* a0;
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            Qt::ItemFlags*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new Qt::ItemFlags((sipSelfWasArg ? sipCpp->QSqlTableModel::flags(*a0) : sipCpp->flags(*a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_Qt_ItemFlags,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_flags, doc_QSqlTableModel_flags);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_data, "QSqlTableModel.data(QModelIndex, int role=Qt.DisplayRole) -> object");

extern "C" {static PyObject *meth_QSqlTableModel_data(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_data(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex* a0;
        int a1 = Qt::DisplayRole;
        const QSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|i", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, &a1))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant((sipSelfWasArg ? sipCpp->QSqlTableModel::data(*a0,a1) : sipCpp->data(*a0,a1)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_data, doc_QSqlTableModel_data);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setData, "QSqlTableModel.setData(QModelIndex, object, int role=Qt.EditRole) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_setData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex* a0;
        const QVariant* a1;
        int a1State = 0;
        int a2 = Qt::EditRole;
        QSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9J1|i", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0, sipType_QVariant,&a1, &a1State, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlTableModel::setData(*a0,*a1,a2) : sipCpp->setData(*a0,*a1,a2));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setData, doc_QSqlTableModel_setData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_headerData, "QSqlTableModel.headerData(int, Qt.Orientation, int role=Qt.DisplayRole) -> object");

extern "C" {static PyObject *meth_QSqlTableModel_headerData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_headerData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        Qt::Orientation a1;
        int a2 = Qt::DisplayRole;
        const QSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiE|i", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, sipType_Qt_Orientation, &a1, &a2))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant((sipSelfWasArg ? sipCpp->QSqlTableModel::headerData(a0,a1,a2) : sipCpp->headerData(a0,a1,a2)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_headerData, doc_QSqlTableModel_headerData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_isDirty, "QSqlTableModel.isDirty(QModelIndex) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_isDirty(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_isDirty(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isDirty(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_isDirty, doc_QSqlTableModel_isDirty);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_clear, "QSqlTableModel.clear()");

extern "C" {static PyObject *meth_QSqlTableModel_clear(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_clear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::clear() : sipCpp->clear());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_clear, doc_QSqlTableModel_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setEditStrategy, "QSqlTableModel.setEditStrategy(QSqlTableModel.EditStrategy)");

extern "C" {static PyObject *meth_QSqlTableModel_setEditStrategy(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setEditStrategy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlTableModel::EditStrategy a0;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QSqlTableModel_EditStrategy, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::setEditStrategy(a0) : sipCpp->setEditStrategy(a0));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setEditStrategy, doc_QSqlTableModel_setEditStrategy);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_editStrategy, "QSqlTableModel.editStrategy() -> QSqlTableModel.EditStrategy");

extern "C" {static PyObject *meth_QSqlTableModel_editStrategy(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_editStrategy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QSqlTableModel::EditStrategy sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->editStrategy();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QSqlTableModel_EditStrategy);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_editStrategy, doc_QSqlTableModel_editStrategy);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_primaryKey, "QSqlTableModel.primaryKey() -> QSqlIndex");

extern "C" {static PyObject *meth_QSqlTableModel_primaryKey(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_primaryKey(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QSqlIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlIndex(sipCpp->primaryKey());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_primaryKey, doc_QSqlTableModel_primaryKey);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_database, "QSqlTableModel.database() -> QSqlDatabase");

extern "C" {static PyObject *meth_QSqlTableModel_database(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_database(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QSqlDatabase*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlDatabase(sipCpp->database());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlDatabase,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_database, doc_QSqlTableModel_database);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_fieldIndex, "QSqlTableModel.fieldIndex(str) -> int");

extern "C" {static PyObject *meth_QSqlTableModel_fieldIndex(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_fieldIndex(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QString,&a0, &a0State))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->fieldIndex(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_fieldIndex, doc_QSqlTableModel_fieldIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_sort, "QSqlTableModel.sort(int, Qt.SortOrder)");

extern "C" {static PyObject *meth_QSqlTableModel_sort(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_sort(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        Qt::SortOrder a1;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiE", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, sipType_Qt_SortOrder, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::sort(a0,a1) : sipCpp->sort(a0,a1));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_sort, doc_QSqlTableModel_sort);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setSort, "QSqlTableModel.setSort(int, Qt.SortOrder)");

extern "C" {static PyObject *meth_QSqlTableModel_setSort(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setSort(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        Qt::SortOrder a1;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiE", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, sipType_Qt_SortOrder, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::setSort(a0,a1) : sipCpp->setSort(a0,a1));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setSort, doc_QSqlTableModel_setSort);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_filter, "QSqlTableModel.filter() -> str");

extern "C" {static PyObject *meth_QSqlTableModel_filter(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_filter(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->filter());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_filter, doc_QSqlTableModel_filter);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setFilter, "QSqlTableModel.setFilter(str)");

extern "C" {static PyObject *meth_QSqlTableModel_setFilter(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setFilter(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::setFilter(*a0) : sipCpp->setFilter(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setFilter, doc_QSqlTableModel_setFilter);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_rowCount, "QSqlTableModel.rowCount(QModelIndex parent=QModelIndex()) -> int");

extern "C" {static PyObject *meth_QSqlTableModel_rowCount(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_rowCount(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex& a0def = QModelIndex();
        const QModelIndex* a0 = &a0def;
        const QSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlTableModel::rowCount(*a0) : sipCpp->rowCount(*a0));
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_rowCount, doc_QSqlTableModel_rowCount);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_removeColumns, "QSqlTableModel.removeColumns(int, int, QModelIndex parent=QModelIndex()) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_removeColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_removeColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        const QModelIndex& a2def = QModelIndex();
        const QModelIndex* a2 = &a2def;
        QSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|J9", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlTableModel::removeColumns(a0,a1,*a2) : sipCpp->removeColumns(a0,a1,*a2));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_removeColumns, doc_QSqlTableModel_removeColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_removeRows, "QSqlTableModel.removeRows(int, int, QModelIndex parent=QModelIndex()) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_removeRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_removeRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        const QModelIndex& a2def = QModelIndex();
        const QModelIndex* a2 = &a2def;
        QSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|J9", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlTableModel::removeRows(a0,a1,*a2) : sipCpp->removeRows(a0,a1,*a2));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_removeRows, doc_QSqlTableModel_removeRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_insertRows, "QSqlTableModel.insertRows(int, int, QModelIndex parent=QModelIndex()) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_insertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_insertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        const QModelIndex& a2def = QModelIndex();
        const QModelIndex* a2 = &a2def;
        QSqlTableModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|J9", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlTableModel::insertRows(a0,a1,*a2) : sipCpp->insertRows(a0,a1,*a2));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_insertRows, doc_QSqlTableModel_insertRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_insertRecord, "QSqlTableModel.insertRecord(int, QSqlRecord) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_insertRecord(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_insertRecord(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRecord* a1;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, sipType_QSqlRecord, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->insertRecord(a0,*a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_insertRecord, doc_QSqlTableModel_insertRecord);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setRecord, "QSqlTableModel.setRecord(int, QSqlRecord) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_setRecord(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setRecord(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRecord* a1;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, sipType_QSqlRecord, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->setRecord(a0,*a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setRecord, doc_QSqlTableModel_setRecord);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_revertRow, "QSqlTableModel.revertRow(int)");

extern "C" {static PyObject *meth_QSqlTableModel_revertRow(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_revertRow(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::revertRow(a0) : sipCpp->revertRow(a0));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_revertRow, doc_QSqlTableModel_revertRow);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_submit, "QSqlTableModel.submit() -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_submit(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_submit(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlTableModel::submit() : sipCpp->submit());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_submit, doc_QSqlTableModel_submit);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_revert, "QSqlTableModel.revert()");

extern "C" {static PyObject *meth_QSqlTableModel_revert(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_revert(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlTableModel::revert() : sipCpp->revert());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_revert, doc_QSqlTableModel_revert);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_submitAll, "QSqlTableModel.submitAll() -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_submitAll(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_submitAll(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->submitAll();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_submitAll, doc_QSqlTableModel_submitAll);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_revertAll, "QSqlTableModel.revertAll()");

extern "C" {static PyObject *meth_QSqlTableModel_revertAll(PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_revertAll(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlTableModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->revertAll();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_revertAll, doc_QSqlTableModel_revertAll);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_updateRowInTable, "QSqlTableModel.updateRowInTable(int, QSqlRecord) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_updateRowInTable(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_updateRowInTable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        const QSqlRecord* a1;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0, sipType_QSqlRecord, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_updateRowInTable(sipSelfWasArg,a0,*a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_updateRowInTable, doc_QSqlTableModel_updateRowInTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_insertRowIntoTable, "QSqlTableModel.insertRowIntoTable(QSqlRecord) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_insertRowIntoTable(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_insertRowIntoTable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlRecord* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QSqlRecord, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_insertRowIntoTable(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_insertRowIntoTable, doc_QSqlTableModel_insertRowIntoTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_deleteRowFromTable, "QSqlTableModel.deleteRowFromTable(int) -> bool");

extern "C" {static PyObject *meth_QSqlTableModel_deleteRowFromTable(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_deleteRowFromTable(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bi", &sipSelf, sipType_QSqlTableModel, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_deleteRowFromTable(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_deleteRowFromTable, doc_QSqlTableModel_deleteRowFromTable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_orderByClause, "QSqlTableModel.orderByClause() -> str");

extern "C" {static PyObject *meth_QSqlTableModel_orderByClause(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_orderByClause(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtectVirt_orderByClause(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_orderByClause, doc_QSqlTableModel_orderByClause);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_selectStatement, "QSqlTableModel.selectStatement() -> str");

extern "C" {static PyObject *meth_QSqlTableModel_selectStatement(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_selectStatement(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlTableModel, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtectVirt_selectStatement(sipSelfWasArg));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_selectStatement, doc_QSqlTableModel_selectStatement);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setPrimaryKey, "QSqlTableModel.setPrimaryKey(QSqlIndex)");

extern "C" {static PyObject *meth_QSqlTableModel_setPrimaryKey(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setPrimaryKey(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlIndex* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QSqlIndex, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setPrimaryKey(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setPrimaryKey, doc_QSqlTableModel_setPrimaryKey);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_setQuery, "QSqlTableModel.setQuery(QSqlQuery)");

extern "C" {static PyObject *meth_QSqlTableModel_setQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_setQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery* a0;
        sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QSqlQuery, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setQuery(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_setQuery, doc_QSqlTableModel_setQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlTableModel_indexInQuery, "QSqlTableModel.indexInQuery(QModelIndex) -> QModelIndex");

extern "C" {static PyObject *meth_QSqlTableModel_indexInQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlTableModel_indexInQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const sipQSqlTableModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlTableModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            QModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QModelIndex(sipCpp->sipProtect_indexInQuery(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlTableModel, sipName_indexInQuery, doc_QSqlTableModel_indexInQuery);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlTableModel(void *, const sipTypeDef *);}
static void *cast_QSqlTableModel(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSqlTableModel)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QSqlQueryModel)->ctd_cast((QSqlQueryModel *)(QSqlTableModel *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlTableModel(void *, int);}
static void release_QSqlTableModel(void *sipCppV,int)
{
    QSqlTableModel *sipCpp = reinterpret_cast<QSqlTableModel *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSqlTableModel(sipSimpleWrapper *);}
static void dealloc_QSqlTableModel(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlTableModel *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlTableModel(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlTableModel(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlTableModel(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQSqlTableModel *sipCpp = 0;

    {
        QObject* a0 = 0;
        QSqlDatabase a1def = QSqlDatabase();
        QSqlDatabase* a1 = &a1def;

        static const char *sipKwdList[] = {
            sipName_parent,
            sipName_db,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JHJ9", sipType_QObject, &a0, sipOwner, sipType_QSqlDatabase, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlTableModel(a0,*a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSqlTableModel[] = {{19, 255, 1}};


static PyMethodDef methods_QSqlTableModel[] = {
    {SIP_MLNAME_CAST(sipName_beginInsertColumns), (PyCFunction)meth_QSqlTableModel_beginInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginInsertRows), (PyCFunction)meth_QSqlTableModel_beginInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveColumns), (PyCFunction)meth_QSqlTableModel_beginMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveRows), (PyCFunction)meth_QSqlTableModel_beginMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveColumns), (PyCFunction)meth_QSqlTableModel_beginRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveRows), (PyCFunction)meth_QSqlTableModel_beginRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginResetModel), (PyCFunction)meth_QSqlTableModel_beginResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_changePersistentIndex), (PyCFunction)meth_QSqlTableModel_changePersistentIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_changePersistentIndexList), (PyCFunction)meth_QSqlTableModel_changePersistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QSqlTableModel_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_clear), meth_QSqlTableModel_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_clear)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QSqlTableModel_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createIndex), (PyCFunction)meth_QSqlTableModel_createIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QSqlTableModel_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_data), (PyCFunction)meth_QSqlTableModel_data, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_data)},
    {SIP_MLNAME_CAST(sipName_database), meth_QSqlTableModel_database, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_database)},
    {SIP_MLNAME_CAST(sipName_decodeData), (PyCFunction)meth_QSqlTableModel_decodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_deleteRowFromTable), (PyCFunction)meth_QSqlTableModel_deleteRowFromTable, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_deleteRowFromTable)},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QSqlTableModel_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_editStrategy), meth_QSqlTableModel_editStrategy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_editStrategy)},
    {SIP_MLNAME_CAST(sipName_encodeData), (PyCFunction)meth_QSqlTableModel_encodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertColumns), (PyCFunction)meth_QSqlTableModel_endInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertRows), (PyCFunction)meth_QSqlTableModel_endInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveColumns), (PyCFunction)meth_QSqlTableModel_endMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveRows), (PyCFunction)meth_QSqlTableModel_endMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveColumns), (PyCFunction)meth_QSqlTableModel_endRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveRows), (PyCFunction)meth_QSqlTableModel_endRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endResetModel), (PyCFunction)meth_QSqlTableModel_endResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_fieldIndex), meth_QSqlTableModel_fieldIndex, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_fieldIndex)},
    {SIP_MLNAME_CAST(sipName_filter), meth_QSqlTableModel_filter, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_filter)},
    {SIP_MLNAME_CAST(sipName_flags), meth_QSqlTableModel_flags, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_flags)},
    {SIP_MLNAME_CAST(sipName_headerData), (PyCFunction)meth_QSqlTableModel_headerData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_headerData)},
    {SIP_MLNAME_CAST(sipName_indexInQuery), (PyCFunction)meth_QSqlTableModel_indexInQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_indexInQuery)},
    {SIP_MLNAME_CAST(sipName_insertRecord), meth_QSqlTableModel_insertRecord, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_insertRecord)},
    {SIP_MLNAME_CAST(sipName_insertRowIntoTable), (PyCFunction)meth_QSqlTableModel_insertRowIntoTable, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_insertRowIntoTable)},
    {SIP_MLNAME_CAST(sipName_insertRows), (PyCFunction)meth_QSqlTableModel_insertRows, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_insertRows)},
    {SIP_MLNAME_CAST(sipName_isDirty), meth_QSqlTableModel_isDirty, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_isDirty)},
    {SIP_MLNAME_CAST(sipName_orderByClause), (PyCFunction)meth_QSqlTableModel_orderByClause, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_orderByClause)},
    {SIP_MLNAME_CAST(sipName_persistentIndexList), (PyCFunction)meth_QSqlTableModel_persistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_primaryKey), meth_QSqlTableModel_primaryKey, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_primaryKey)},
    {SIP_MLNAME_CAST(sipName_queryChange), (PyCFunction)meth_QSqlTableModel_queryChange, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QSqlTableModel_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_removeColumns), (PyCFunction)meth_QSqlTableModel_removeColumns, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_removeColumns)},
    {SIP_MLNAME_CAST(sipName_removeRows), (PyCFunction)meth_QSqlTableModel_removeRows, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_removeRows)},
    {SIP_MLNAME_CAST(sipName_reset), (PyCFunction)meth_QSqlTableModel_reset, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_resetInternalData), (PyCFunction)meth_QSqlTableModel_resetInternalData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_revert), meth_QSqlTableModel_revert, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_revert)},
    {SIP_MLNAME_CAST(sipName_revertAll), meth_QSqlTableModel_revertAll, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_revertAll)},
    {SIP_MLNAME_CAST(sipName_revertRow), meth_QSqlTableModel_revertRow, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_revertRow)},
    {SIP_MLNAME_CAST(sipName_rowCount), (PyCFunction)meth_QSqlTableModel_rowCount, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_rowCount)},
    {SIP_MLNAME_CAST(sipName_select), meth_QSqlTableModel_select, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_select)},
    {SIP_MLNAME_CAST(sipName_selectStatement), (PyCFunction)meth_QSqlTableModel_selectStatement, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_selectStatement)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QSqlTableModel_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QSqlTableModel_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setData), (PyCFunction)meth_QSqlTableModel_setData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_setData)},
    {SIP_MLNAME_CAST(sipName_setEditStrategy), meth_QSqlTableModel_setEditStrategy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_setEditStrategy)},
    {SIP_MLNAME_CAST(sipName_setFilter), meth_QSqlTableModel_setFilter, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_setFilter)},
    {SIP_MLNAME_CAST(sipName_setLastError), (PyCFunction)meth_QSqlTableModel_setLastError, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setPrimaryKey), (PyCFunction)meth_QSqlTableModel_setPrimaryKey, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_setPrimaryKey)},
    {SIP_MLNAME_CAST(sipName_setQuery), (PyCFunction)meth_QSqlTableModel_setQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_setQuery)},
    {SIP_MLNAME_CAST(sipName_setRecord), meth_QSqlTableModel_setRecord, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_setRecord)},
    {SIP_MLNAME_CAST(sipName_setRoleNames), (PyCFunction)meth_QSqlTableModel_setRoleNames, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setSort), meth_QSqlTableModel_setSort, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_setSort)},
    {SIP_MLNAME_CAST(sipName_setTable), meth_QSqlTableModel_setTable, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_setTable)},
    {SIP_MLNAME_CAST(sipName_sort), meth_QSqlTableModel_sort, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_sort)},
    {SIP_MLNAME_CAST(sipName_submit), meth_QSqlTableModel_submit, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_submit)},
    {SIP_MLNAME_CAST(sipName_submitAll), meth_QSqlTableModel_submitAll, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_submitAll)},
    {SIP_MLNAME_CAST(sipName_tableName), meth_QSqlTableModel_tableName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlTableModel_tableName)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QSqlTableModel_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateRowInTable), (PyCFunction)meth_QSqlTableModel_updateRowInTable, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlTableModel_updateRowInTable)}
};

static sipEnumMemberDef enummembers_QSqlTableModel[] = {
    {sipName_OnFieldChange, static_cast<int>(QSqlTableModel::OnFieldChange), 28},
    {sipName_OnManualSubmit, static_cast<int>(QSqlTableModel::OnManualSubmit), 28},
    {sipName_OnRowChange, static_cast<int>(QSqlTableModel::OnRowChange), 28},
};


/* Define this type's signals. */
static const pyqt4QtSignal signals_QSqlTableModel[] = {
    {"beforeDelete(int)", "\1QSqlTableModel.beforeDelete[int]", 0, 0},
    {"beforeUpdate(int,QSqlRecord&)", "\1QSqlTableModel.beforeUpdate[int, QSqlRecord]", 0, 0},
    {"beforeInsert(QSqlRecord&)", "\1QSqlTableModel.beforeInsert[QSqlRecord]", 0, 0},
    {"primeInsert(int,QSqlRecord&)", "\1QSqlTableModel.primeInsert[int, QSqlRecord]", 0, 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_QSqlTableModel, "\1QSqlTableModel(QObject parent=None, QSqlDatabase db=QSqlDatabase())");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlTableModel = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QSqlTableModel,
        {0}
    },
    {
        sipNameNr_QSqlTableModel,
        {0, 0, 1},
        70, methods_QSqlTableModel,
        3, enummembers_QSqlTableModel,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlTableModel,
    -1,
    -1,
    supers_QSqlTableModel,
    0,
    init_type_QSqlTableModel,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlTableModel,
    0,
    0,
    0,
    release_QSqlTableModel,
    cast_QSqlTableModel,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QSqlTableModel::staticMetaObject,
    0,
    signals_QSqlTableModel,
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrelationaltablemodel.sip"
#include <qsqlrelationaltablemodel.h>
#line 10224 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 10228 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


PyDoc_STRVAR(doc_QSqlRelation_tableName, "QSqlRelation.tableName() -> str");

extern "C" {static PyObject *meth_QSqlRelation_tableName(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelation_tableName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlRelation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRelation, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->tableName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelation, sipName_tableName, doc_QSqlRelation_tableName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelation_indexColumn, "QSqlRelation.indexColumn() -> str");

extern "C" {static PyObject *meth_QSqlRelation_indexColumn(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelation_indexColumn(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlRelation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRelation, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->indexColumn());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelation, sipName_indexColumn, doc_QSqlRelation_indexColumn);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelation_displayColumn, "QSqlRelation.displayColumn() -> str");

extern "C" {static PyObject *meth_QSqlRelation_displayColumn(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelation_displayColumn(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlRelation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRelation, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->displayColumn());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelation, sipName_displayColumn, doc_QSqlRelation_displayColumn);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelation_isValid, "QSqlRelation.isValid() -> bool");

extern "C" {static PyObject *meth_QSqlRelation_isValid(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelation_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlRelation *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRelation, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelation, sipName_isValid, doc_QSqlRelation_isValid);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlRelation(void *, const sipTypeDef *);}
static void *cast_QSqlRelation(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlRelation)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlRelation(void *, int);}
static void release_QSqlRelation(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSqlRelation *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSqlRelation(void *, SIP_SSIZE_T, const void *);}
static void assign_QSqlRelation(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSqlRelation *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSqlRelation *>(sipSrc);
}


extern "C" {static void *array_QSqlRelation(SIP_SSIZE_T);}
static void *array_QSqlRelation(SIP_SSIZE_T sipNrElem)
{
    return new QSqlRelation[sipNrElem];
}


extern "C" {static void *copy_QSqlRelation(const void *, SIP_SSIZE_T);}
static void *copy_QSqlRelation(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSqlRelation(reinterpret_cast<const QSqlRelation *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSqlRelation(sipSimpleWrapper *);}
static void dealloc_QSqlRelation(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlRelation(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSqlRelation(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlRelation(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSqlRelation *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlRelation();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QString* a1;
        int a1State = 0;
        const QString* a2;
        int a2State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1J1J1", sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State, sipType_QString,&a2, &a2State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlRelation(*a0,*a1,*a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);
            sipReleaseType(const_cast<QString *>(a2),sipType_QString,a2State);

            return sipCpp;
        }
    }

    {
        const QSqlRelation* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlRelation, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlRelation(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QSqlRelation[] = {
    {SIP_MLNAME_CAST(sipName_displayColumn), meth_QSqlRelation_displayColumn, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelation_displayColumn)},
    {SIP_MLNAME_CAST(sipName_indexColumn), meth_QSqlRelation_indexColumn, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelation_indexColumn)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QSqlRelation_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelation_isValid)},
    {SIP_MLNAME_CAST(sipName_tableName), meth_QSqlRelation_tableName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelation_tableName)}
};

PyDoc_STRVAR(doc_QSqlRelation, "\1QSqlRelation()\n"
    "QSqlRelation(str, str, str)\n"
    "QSqlRelation(QSqlRelation)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlRelation = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSqlRelation,
        {0}
    },
    {
        sipNameNr_QSqlRelation,
        {0, 0, 1},
        4, methods_QSqlRelation,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlRelation,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QSqlRelation,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlRelation,
    assign_QSqlRelation,
    array_QSqlRelation,
    copy_QSqlRelation,
    release_QSqlRelation,
    cast_QSqlRelation,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrelationaldelegate.sip"
#include <qsqlrelationaldelegate.h>
#line 10523 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 10527 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qwidget.sip"
#include <qwidget.h>
#line 10530 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 122 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 10533 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 10536 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 1130 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qstyleoption.sip"
#include <qstyleoption.h>
#line 10539 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10542 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qpainter.sip"
#include <qpainter.h>
#line 10545 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 10548 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 10551 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qpixmap.sip"
#include <qpixmap.h>
#line 10554 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10557 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 38 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qitemeditorfactory.sip"
#include <qitemeditorfactory.h>
#line 10560 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 10563 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qabstractitemdelegate.sip"
#include <qabstractitemdelegate.h>
#line 10566 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 807 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10569 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qabstractitemview.sip"
#include <qabstractitemview.h>
#line 10572 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtGui/qfontmetrics.sip"
#include <qfontmetrics.h>
#line 10575 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10578 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10581 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 10584 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 10587 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 10590 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 10593 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 10596 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 10599 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 10602 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlRelationalDelegate : public QSqlRelationalDelegate
{
public:
    sipQSqlRelationalDelegate(QObject*);
    virtual ~sipQSqlRelationalDelegate();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtect_drawBackground(QPainter*,const QStyleOptionViewItem&,const QModelIndex&) const;
    void sipProtectVirt_drawCheck(bool,QPainter*,const QStyleOptionViewItem&,const QRect&,Qt::CheckState) const;
    void sipProtectVirt_drawDecoration(bool,QPainter*,const QStyleOptionViewItem&,const QRect&,const QPixmap&) const;
    void sipProtectVirt_drawDisplay(bool,QPainter*,const QStyleOptionViewItem&,const QRect&,const QString&) const;
    void sipProtectVirt_drawFocus(bool,QPainter*,const QStyleOptionViewItem&,const QRect&) const;
    bool sipProtectVirt_eventFilter(bool,QObject*,QEvent*);
    bool sipProtectVirt_editorEvent(bool,QEvent*,QAbstractItemModel*,const QStyleOptionViewItem&,const QModelIndex&);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool event(QEvent*);
    bool editorEvent(QEvent*,QAbstractItemModel*,const QStyleOptionViewItem&,const QModelIndex&);
    bool eventFilter(QObject*,QEvent*);
    void drawFocus(QPainter*,const QStyleOptionViewItem&,const QRect&) const;
    void drawDisplay(QPainter*,const QStyleOptionViewItem&,const QRect&,const QString&) const;
    void drawDecoration(QPainter*,const QStyleOptionViewItem&,const QRect&,const QPixmap&) const;
    void drawCheck(QPainter*,const QStyleOptionViewItem&,const QRect&,Qt::CheckState) const;
    void updateEditorGeometry(QWidget*,const QStyleOptionViewItem&,const QModelIndex&) const;
    QSize sizeHint(const QStyleOptionViewItem&,const QModelIndex&) const;
    void paint(QPainter*,const QStyleOptionViewItem&,const QModelIndex&) const;
    void setModelData(QWidget*,QAbstractItemModel*,const QModelIndex&) const;
    void setEditorData(QWidget*,const QModelIndex&) const;
    QWidget* createEditor(QWidget*,const QStyleOptionViewItem&,const QModelIndex&) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlRelationalDelegate(const sipQSqlRelationalDelegate &);
    sipQSqlRelationalDelegate &operator = (const sipQSqlRelationalDelegate &);

    char sipPyMethods[18];
};

sipQSqlRelationalDelegate::sipQSqlRelationalDelegate(QObject*a0): QSqlRelationalDelegate(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlRelationalDelegate::~sipQSqlRelationalDelegate()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQSqlRelationalDelegate::metaObject() const
{
    return sip_QtSql_qt_metaobject(sipPySelf,sipType_QSqlRelationalDelegate);
}

int sipQSqlRelationalDelegate::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QSqlRelationalDelegate::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtSql_qt_metacall(sipPySelf,sipType_QSqlRelationalDelegate,_c,_id,_a);

    return _id;
}

void *sipQSqlRelationalDelegate::qt_metacast(const char *_clname)
{
    return (sip_QtSql_qt_metacast(sipPySelf, sipType_QSqlRelationalDelegate, _clname)) ? this : QSqlRelationalDelegate::qt_metacast(_clname);
}

void sipQSqlRelationalDelegate::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalDelegate::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalDelegate::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtSql_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalDelegate::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtSql_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlRelationalDelegate::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtSql_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalDelegate::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QSqlRelationalDelegate::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtSql_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlRelationalDelegate::editorEvent(QEvent*a0,QAbstractItemModel*a1,const QStyleOptionViewItem& a2,const QModelIndex& a3)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_editorEvent);

    if (!sipMeth)
        return QSqlRelationalDelegate::editorEvent(a0,a1,a2,a3);

    typedef bool (*sipVH_QtGui_73)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*,QAbstractItemModel*,const QStyleOptionViewItem&,const QModelIndex&);

    return ((sipVH_QtGui_73)(sipModuleAPI_QtSql_QtGui->em_virthandlers[73]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

bool sipQSqlRelationalDelegate::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QSqlRelationalDelegate::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtSql_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlRelationalDelegate::drawFocus(QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[8]),sipPySelf,NULL,sipName_drawFocus);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::drawFocus(a0,a1,a2);
        return;
    }

    typedef void (*sipVH_QtGui_163)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QPainter*,const QStyleOptionViewItem&,const QRect&);

    ((sipVH_QtGui_163)(sipModuleAPI_QtSql_QtGui->em_virthandlers[163]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlRelationalDelegate::drawDisplay(QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2,const QString& a3) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,NULL,sipName_drawDisplay);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::drawDisplay(a0,a1,a2,a3);
        return;
    }

    typedef void (*sipVH_QtGui_164)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QPainter*,const QStyleOptionViewItem&,const QRect&,const QString&);

    ((sipVH_QtGui_164)(sipModuleAPI_QtSql_QtGui->em_virthandlers[164]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

void sipQSqlRelationalDelegate::drawDecoration(QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2,const QPixmap& a3) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,NULL,sipName_drawDecoration);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::drawDecoration(a0,a1,a2,a3);
        return;
    }

    typedef void (*sipVH_QtGui_165)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QPainter*,const QStyleOptionViewItem&,const QRect&,const QPixmap&);

    ((sipVH_QtGui_165)(sipModuleAPI_QtSql_QtGui->em_virthandlers[165]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

void sipQSqlRelationalDelegate::drawCheck(QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2,Qt::CheckState a3) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,NULL,sipName_drawCheck);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::drawCheck(a0,a1,a2,a3);
        return;
    }

    typedef void (*sipVH_QtGui_166)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QPainter*,const QStyleOptionViewItem&,const QRect&,Qt::CheckState);

    ((sipVH_QtGui_166)(sipModuleAPI_QtSql_QtGui->em_virthandlers[166]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

void sipQSqlRelationalDelegate::updateEditorGeometry(QWidget*a0,const QStyleOptionViewItem& a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[12]),sipPySelf,NULL,sipName_updateEditorGeometry);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::updateEditorGeometry(a0,a1,a2);
        return;
    }

    typedef void (*sipVH_QtGui_76)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QWidget*,const QStyleOptionViewItem&,const QModelIndex&);

    ((sipVH_QtGui_76)(sipModuleAPI_QtSql_QtGui->em_virthandlers[76]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

QSize sipQSqlRelationalDelegate::sizeHint(const QStyleOptionViewItem& a0,const QModelIndex& a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[13]),sipPySelf,NULL,sipName_sizeHint);

    if (!sipMeth)
        return QSqlRelationalDelegate::sizeHint(a0,a1);

    typedef QSize (*sipVH_QtGui_80)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QStyleOptionViewItem&,const QModelIndex&);

    return ((sipVH_QtGui_80)(sipModuleAPI_QtSql_QtGui->em_virthandlers[80]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQSqlRelationalDelegate::paint(QPainter*a0,const QStyleOptionViewItem& a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[14]),sipPySelf,NULL,sipName_paint);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::paint(a0,a1,a2);
        return;
    }

    typedef void (*sipVH_QtGui_48)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QPainter*,const QStyleOptionViewItem&,const QModelIndex&);

    ((sipVH_QtGui_48)(sipModuleAPI_QtSql_QtGui->em_virthandlers[48]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlRelationalDelegate::setModelData(QWidget*a0,QAbstractItemModel*a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[15]),sipPySelf,NULL,sipName_setModelData);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::setModelData(a0,a1,a2);
        return;
    }

    typedef void (*sipVH_QtGui_77)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QWidget*,QAbstractItemModel*,const QModelIndex&);

    ((sipVH_QtGui_77)(sipModuleAPI_QtSql_QtGui->em_virthandlers[77]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlRelationalDelegate::setEditorData(QWidget*a0,const QModelIndex& a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[16]),sipPySelf,NULL,sipName_setEditorData);

    if (!sipMeth)
    {
        QSqlRelationalDelegate::setEditorData(a0,a1);
        return;
    }

    typedef void (*sipVH_QtGui_78)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QWidget*,const QModelIndex&);

    ((sipVH_QtGui_78)(sipModuleAPI_QtSql_QtGui->em_virthandlers[78]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QWidget* sipQSqlRelationalDelegate::createEditor(QWidget*a0,const QStyleOptionViewItem& a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[17]),sipPySelf,NULL,sipName_createEditor);

    if (!sipMeth)
        return QSqlRelationalDelegate::createEditor(a0,a1,a2);

    typedef QWidget* (*sipVH_QtGui_79)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QWidget*,const QStyleOptionViewItem&,const QModelIndex&);

    return ((sipVH_QtGui_79)(sipModuleAPI_QtSql_QtGui->em_virthandlers[79]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

QObject* sipQSqlRelationalDelegate::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQSqlRelationalDelegate::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQSqlRelationalDelegate::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQSqlRelationalDelegate::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQSqlRelationalDelegate::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQSqlRelationalDelegate::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQSqlRelationalDelegate::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQSqlRelationalDelegate::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

void sipQSqlRelationalDelegate::sipProtect_drawBackground(QPainter*a0,const QStyleOptionViewItem& a1,const QModelIndex& a2) const
{
    QItemDelegate::drawBackground(a0,a1,a2);
}

void sipQSqlRelationalDelegate::sipProtectVirt_drawCheck(bool sipSelfWasArg,QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2,Qt::CheckState a3) const
{
    (sipSelfWasArg ? QItemDelegate::drawCheck(a0,a1,a2,a3) : drawCheck(a0,a1,a2,a3));
}

void sipQSqlRelationalDelegate::sipProtectVirt_drawDecoration(bool sipSelfWasArg,QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2,const QPixmap& a3) const
{
    (sipSelfWasArg ? QItemDelegate::drawDecoration(a0,a1,a2,a3) : drawDecoration(a0,a1,a2,a3));
}

void sipQSqlRelationalDelegate::sipProtectVirt_drawDisplay(bool sipSelfWasArg,QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2,const QString& a3) const
{
    (sipSelfWasArg ? QItemDelegate::drawDisplay(a0,a1,a2,a3) : drawDisplay(a0,a1,a2,a3));
}

void sipQSqlRelationalDelegate::sipProtectVirt_drawFocus(bool sipSelfWasArg,QPainter*a0,const QStyleOptionViewItem& a1,const QRect& a2) const
{
    (sipSelfWasArg ? QItemDelegate::drawFocus(a0,a1,a2) : drawFocus(a0,a1,a2));
}

bool sipQSqlRelationalDelegate::sipProtectVirt_eventFilter(bool sipSelfWasArg,QObject*a0,QEvent*a1)
{
    return (sipSelfWasArg ? QItemDelegate::eventFilter(a0,a1) : eventFilter(a0,a1));
}

bool sipQSqlRelationalDelegate::sipProtectVirt_editorEvent(bool sipSelfWasArg,QEvent*a0,QAbstractItemModel*a1,const QStyleOptionViewItem& a2,const QModelIndex& a3)
{
    return (sipSelfWasArg ? QItemDelegate::editorEvent(a0,a1,a2,a3) : editorEvent(a0,a1,a2,a3));
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_sender, "QSqlRelationalDelegate.sender() -> QObject");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp))
        {
            QObject*sipRes = 0;

#line 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (helper)
            sipRes = helper(sipRes);
#line 11121 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_sender, doc_QSqlRelationalDelegate_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_receivers, "QSqlRelationalDelegate.receivers(SIGNAL()) -> int");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        char* a0;
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 11166 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_receivers, doc_QSqlRelationalDelegate_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_timerEvent, "QSqlRelationalDelegate.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_timerEvent, doc_QSqlRelationalDelegate_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_childEvent, "QSqlRelationalDelegate.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_childEvent, doc_QSqlRelationalDelegate_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_customEvent, "QSqlRelationalDelegate.customEvent(QEvent)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_customEvent, doc_QSqlRelationalDelegate_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_connectNotify, "QSqlRelationalDelegate.connectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_connectNotify, doc_QSqlRelationalDelegate_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_disconnectNotify, "QSqlRelationalDelegate.disconnectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_disconnectNotify, doc_QSqlRelationalDelegate_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_senderSignalIndex, "QSqlRelationalDelegate.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_senderSignalIndex, doc_QSqlRelationalDelegate_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_drawBackground, "QSqlRelationalDelegate.drawBackground(QPainter, QStyleOptionViewItem, QModelIndex)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_drawBackground(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_drawBackground(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QPainter* a0;
        const QStyleOptionViewItem* a1;
        const QModelIndex* a2;
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8J9J9", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QPainter, &a0, sipType_QStyleOptionViewItem, &a1, sipType_QModelIndex, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_drawBackground(a0,*a1,*a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_drawBackground, doc_QSqlRelationalDelegate_drawBackground);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_drawCheck, "QSqlRelationalDelegate.drawCheck(QPainter, QStyleOptionViewItem, QRect, Qt.CheckState)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_drawCheck(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_drawCheck(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QPainter* a0;
        const QStyleOptionViewItem* a1;
        const QRect* a2;
        Qt::CheckState a3;
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8J9J9E", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QPainter, &a0, sipType_QStyleOptionViewItem, &a1, sipType_QRect, &a2, sipType_Qt_CheckState, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_drawCheck(sipSelfWasArg,a0,*a1,*a2,a3);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_drawCheck, doc_QSqlRelationalDelegate_drawCheck);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_drawDecoration, "QSqlRelationalDelegate.drawDecoration(QPainter, QStyleOptionViewItem, QRect, QPixmap)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_drawDecoration(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_drawDecoration(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QPainter* a0;
        const QStyleOptionViewItem* a1;
        const QRect* a2;
        const QPixmap* a3;
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8J9J9J9", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QPainter, &a0, sipType_QStyleOptionViewItem, &a1, sipType_QRect, &a2, sipType_QPixmap, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_drawDecoration(sipSelfWasArg,a0,*a1,*a2,*a3);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_drawDecoration, doc_QSqlRelationalDelegate_drawDecoration);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_drawDisplay, "QSqlRelationalDelegate.drawDisplay(QPainter, QStyleOptionViewItem, QRect, str)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_drawDisplay(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_drawDisplay(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QPainter* a0;
        const QStyleOptionViewItem* a1;
        const QRect* a2;
        const QString* a3;
        int a3State = 0;
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8J9J9J1", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QPainter, &a0, sipType_QStyleOptionViewItem, &a1, sipType_QRect, &a2, sipType_QString,&a3, &a3State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_drawDisplay(sipSelfWasArg,a0,*a1,*a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a3),sipType_QString,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_drawDisplay, doc_QSqlRelationalDelegate_drawDisplay);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_drawFocus, "QSqlRelationalDelegate.drawFocus(QPainter, QStyleOptionViewItem, QRect)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_drawFocus(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_drawFocus(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QPainter* a0;
        const QStyleOptionViewItem* a1;
        const QRect* a2;
        const sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8J9J9", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QPainter, &a0, sipType_QStyleOptionViewItem, &a1, sipType_QRect, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_drawFocus(sipSelfWasArg,a0,*a1,*a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_drawFocus, doc_QSqlRelationalDelegate_drawFocus);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_eventFilter, "QSqlRelationalDelegate.eventFilter(QObject, QEvent) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_eventFilter(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_eventFilter(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QObject* a0;
        QEvent* a1;
        sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8J8", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QObject, &a0, sipType_QEvent, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_eventFilter(sipSelfWasArg,a0,a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_eventFilter, doc_QSqlRelationalDelegate_eventFilter);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_editorEvent, "QSqlRelationalDelegate.editorEvent(QEvent, QAbstractItemModel, QStyleOptionViewItem, QModelIndex) -> bool");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_editorEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_editorEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        QAbstractItemModel* a1;
        const QStyleOptionViewItem* a2;
        const QModelIndex* a3;
        sipQSqlRelationalDelegate *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8J8J9J9", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QEvent, &a0, sipType_QAbstractItemModel, &a1, sipType_QStyleOptionViewItem, &a2, sipType_QModelIndex, &a3))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_editorEvent(sipSelfWasArg,a0,a1,*a2,*a3);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_editorEvent, doc_QSqlRelationalDelegate_editorEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_createEditor, "QSqlRelationalDelegate.createEditor(QWidget, QStyleOptionViewItem, QModelIndex) -> QWidget");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_createEditor(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_createEditor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QWidget* a0;
        const QStyleOptionViewItem* a1;
        const QModelIndex* a2;
        sipWrapper *sipOwner = 0;
        const QSqlRelationalDelegate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJHJ9J9", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QWidget, &a0, &sipOwner, sipType_QStyleOptionViewItem, &a1, sipType_QModelIndex, &a2))
        {
            QWidget*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlRelationalDelegate::createEditor(a0,*a1,*a2) : sipCpp->createEditor(a0,*a1,*a2));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QWidget,(PyObject *)sipOwner);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_createEditor, doc_QSqlRelationalDelegate_createEditor);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_setEditorData, "QSqlRelationalDelegate.setEditorData(QWidget, QModelIndex)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_setEditorData(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_setEditorData(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QWidget* a0;
        const QModelIndex* a1;
        const QSqlRelationalDelegate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8J9", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QWidget, &a0, sipType_QModelIndex, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlRelationalDelegate::setEditorData(a0,*a1) : sipCpp->setEditorData(a0,*a1));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_setEditorData, doc_QSqlRelationalDelegate_setEditorData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRelationalDelegate_setModelData, "QSqlRelationalDelegate.setModelData(QWidget, QAbstractItemModel, QModelIndex)");

extern "C" {static PyObject *meth_QSqlRelationalDelegate_setModelData(PyObject *, PyObject *);}
static PyObject *meth_QSqlRelationalDelegate_setModelData(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QWidget* a0;
        QAbstractItemModel* a1;
        PyObject *a1Keep;
        const QModelIndex* a2;
        const QSqlRelationalDelegate *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8@J8J9", &sipSelf, sipType_QSqlRelationalDelegate, &sipCpp, sipType_QWidget, &a0, &a1Keep, sipType_QAbstractItemModel, &a1, sipType_QModelIndex, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlRelationalDelegate::setModelData(a0,a1,*a2) : sipCpp->setModelData(a0,a1,*a2));
            Py_END_ALLOW_THREADS

            sipKeepReference(sipSelf, -1, a1Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRelationalDelegate, sipName_setModelData, doc_QSqlRelationalDelegate_setModelData);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlRelationalDelegate(void *, const sipTypeDef *);}
static void *cast_QSqlRelationalDelegate(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSqlRelationalDelegate)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QItemDelegate)->ctd_cast((QItemDelegate *)(QSqlRelationalDelegate *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlRelationalDelegate(void *, int);}
static void release_QSqlRelationalDelegate(void *sipCppV,int)
{
    QSqlRelationalDelegate *sipCpp = reinterpret_cast<QSqlRelationalDelegate *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSqlRelationalDelegate(sipSimpleWrapper *);}
static void dealloc_QSqlRelationalDelegate(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlRelationalDelegate *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlRelationalDelegate(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlRelationalDelegate(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlRelationalDelegate(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQSqlRelationalDelegate *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlRelationalDelegate(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSqlRelationalDelegate[] = {{257, 1, 1}};


static PyMethodDef methods_QSqlRelationalDelegate[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QSqlRelationalDelegate_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QSqlRelationalDelegate_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createEditor), meth_QSqlRelationalDelegate_createEditor, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalDelegate_createEditor)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QSqlRelationalDelegate_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QSqlRelationalDelegate_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_drawBackground), (PyCFunction)meth_QSqlRelationalDelegate_drawBackground, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_drawCheck), (PyCFunction)meth_QSqlRelationalDelegate_drawCheck, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_drawDecoration), (PyCFunction)meth_QSqlRelationalDelegate_drawDecoration, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_drawDisplay), (PyCFunction)meth_QSqlRelationalDelegate_drawDisplay, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_drawFocus), (PyCFunction)meth_QSqlRelationalDelegate_drawFocus, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_editorEvent), (PyCFunction)meth_QSqlRelationalDelegate_editorEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_eventFilter), (PyCFunction)meth_QSqlRelationalDelegate_eventFilter, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QSqlRelationalDelegate_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QSqlRelationalDelegate_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QSqlRelationalDelegate_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setEditorData), meth_QSqlRelationalDelegate_setEditorData, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalDelegate_setEditorData)},
    {SIP_MLNAME_CAST(sipName_setModelData), meth_QSqlRelationalDelegate_setModelData, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRelationalDelegate_setModelData)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QSqlRelationalDelegate_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QSqlRelationalDelegate, "\1QSqlRelationalDelegate(QObject parent=None)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlRelationalDelegate = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QSqlRelationalDelegate,
        {0}
    },
    {
        sipNameNr_QSqlRelationalDelegate,
        {0, 0, 1},
        18, methods_QSqlRelationalDelegate,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlRelationalDelegate,
    -1,
    -1,
    supers_QSqlRelationalDelegate,
    0,
    init_type_QSqlRelationalDelegate,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlRelationalDelegate,
    0,
    0,
    0,
    release_QSqlRelationalDelegate,
    cast_QSqlRelationalDelegate,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QSqlRelationalDelegate::staticMetaObject,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlquerymodel.sip"
#include <qsqlquerymodel.h>
#line 11846 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 11850 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 11853 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
#include <qabstractitemmodel.h>
#line 11856 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlquery.sip"
#include <qsqlquery.h>
#line 11859 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 11862 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 11865 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 11868 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 11871 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 11874 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qmimedata.sip"
#include <qmimedata.h>
#line 11877 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 139 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qhash.sip"
#include <qhash.h>
#line 11880 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 11883 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 11886 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 11889 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qdatastream.sip"
#include <qdatastream.h>
#line 11892 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 11895 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 11898 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 11901 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 11904 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 139 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qmap.sip"
#include <qmap.h>
#line 11907 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 11910 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 11913 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 11916 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 11919 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 11922 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 11925 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 11928 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 11931 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 11934 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlQueryModel : public QSqlQueryModel
{
public:
    sipQSqlQueryModel(QObject*);
    virtual ~sipQSqlQueryModel();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtect_resetInternalData();
    void sipProtect_encodeData(const QModelIndexList&,QDataStream&) const;
    bool sipProtect_decodeData(int,int,const QModelIndex&,QDataStream&);
    void sipProtect_beginInsertRows(const QModelIndex&,int,int);
    void sipProtect_endInsertRows();
    void sipProtect_beginRemoveRows(const QModelIndex&,int,int);
    void sipProtect_endRemoveRows();
    void sipProtect_beginInsertColumns(const QModelIndex&,int,int);
    void sipProtect_endInsertColumns();
    void sipProtect_beginRemoveColumns(const QModelIndex&,int,int);
    void sipProtect_endRemoveColumns();
    QModelIndexList sipProtect_persistentIndexList() const;
    void sipProtect_reset();
    void sipProtect_changePersistentIndex(const QModelIndex&,const QModelIndex&);
    void sipProtect_changePersistentIndexList(const QModelIndexList&,const QModelIndexList&);
    QModelIndex sipProtect_createIndex(int,int,void*) const;
    bool sipProtect_beginMoveRows(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveRows();
    bool sipProtect_beginMoveColumns(const QModelIndex&,int,int,const QModelIndex&,int);
    void sipProtect_endMoveColumns();
    void sipProtect_beginResetModel();
    void sipProtect_endResetModel();
    void sipProtect_setRoleNames(const QHash<int,QByteArray>&);
    void sipProtectVirt_queryChange(bool);
    QModelIndex sipProtect_indexInQuery(const QModelIndex&) const;
    void sipProtect_setLastError(const QSqlError&);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    void revert();
    bool submit();
    QSize span(const QModelIndex&) const;
    QModelIndexList match(const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags) const;
    QModelIndex buddy(const QModelIndex&) const;
    void sort(int,Qt::SortOrder);
    Qt::ItemFlags flags(const QModelIndex&) const;
    bool removeRows(int,int,const QModelIndex&);
    bool insertRows(int,int,const QModelIndex&);
    Qt::DropActions supportedDropActions() const;
    QMimeData* mimeData(const QModelIndexList&) const;
    QStringList mimeTypes() const;
    bool setItemData(const QModelIndex&,const QMap<int,QVariant>&);
    QMap<int,QVariant> itemData(const QModelIndex&) const;
    bool setData(const QModelIndex&,const QVariant&,int);
    bool dropMimeData(const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);
    QModelIndex index(int,int,const QModelIndex&) const;
    void queryChange();
    bool canFetchMore(const QModelIndex&) const;
    void fetchMore(const QModelIndex&);
    void clear();
    bool removeColumns(int,int,const QModelIndex&);
    bool insertColumns(int,int,const QModelIndex&);
    bool setHeaderData(int,Qt::Orientation,const QVariant&,int);
    QVariant headerData(int,Qt::Orientation,int) const;
    QVariant data(const QModelIndex&,int) const;
    int columnCount(const QModelIndex&) const;
    int rowCount(const QModelIndex&) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlQueryModel(const sipQSqlQueryModel &);
    sipQSqlQueryModel &operator = (const sipQSqlQueryModel &);

    char sipPyMethods[35];
};

sipQSqlQueryModel::sipQSqlQueryModel(QObject*a0): QSqlQueryModel(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlQueryModel::~sipQSqlQueryModel()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQSqlQueryModel::metaObject() const
{
    return sip_QtSql_qt_metaobject(sipPySelf,sipType_QSqlQueryModel);
}

int sipQSqlQueryModel::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QSqlQueryModel::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtSql_qt_metacall(sipPySelf,sipType_QSqlQueryModel,_c,_id,_a);

    return _id;
}

void *sipQSqlQueryModel::qt_metacast(const char *_clname)
{
    return (sip_QtSql_qt_metacast(sipPySelf, sipType_QSqlQueryModel, _clname)) ? this : QSqlQueryModel::qt_metacast(_clname);
}

void sipQSqlQueryModel::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QSqlQueryModel::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QSqlQueryModel::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QSqlQueryModel::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtSql_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QSqlQueryModel::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtSql_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QSqlQueryModel::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtSql_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlQueryModel::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QSqlQueryModel::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtSql_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

bool sipQSqlQueryModel::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QSqlQueryModel::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtSql_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::revert()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_revert);

    if (!sipMeth)
    {
        QSqlQueryModel::revert();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlQueryModel::submit()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_submit);

    if (!sipMeth)
        return QSqlQueryModel::submit();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

QSize sipQSqlQueryModel::span(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[9]),sipPySelf,NULL,sipName_span);

    if (!sipMeth)
        return QSqlQueryModel::span(a0);

    typedef QSize (*sipVH_QtCore_47)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_47)(sipModuleAPI_QtSql_QtCore->em_virthandlers[47]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QModelIndexList sipQSqlQueryModel::match(const QModelIndex& a0,int a1,const QVariant& a2,int a3,Qt::MatchFlags a4) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[10]),sipPySelf,NULL,sipName_match);

    if (!sipMeth)
        return QSqlQueryModel::match(a0,a1,a2,a3,a4);

    typedef QList<QModelIndex> (*sipVH_QtCore_48)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int,const QVariant&,int,Qt::MatchFlags);

    return ((sipVH_QtCore_48)(sipModuleAPI_QtSql_QtCore->em_virthandlers[48]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipQSqlQueryModel::buddy(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,NULL,sipName_buddy);

    if (!sipMeth)
        return QSqlQueryModel::buddy(a0);

    typedef QModelIndex (*sipVH_QtCore_44)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_44)(sipModuleAPI_QtSql_QtCore->em_virthandlers[44]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::sort(int a0,Qt::SortOrder a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,NULL,sipName_sort);

    if (!sipMeth)
    {
        QSqlQueryModel::sort(a0,a1);
        return;
    }

    typedef void (*sipVH_QtCore_49)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::SortOrder);

    ((sipVH_QtCore_49)(sipModuleAPI_QtSql_QtCore->em_virthandlers[49]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

Qt::ItemFlags sipQSqlQueryModel::flags(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[13]),sipPySelf,NULL,sipName_flags);

    if (!sipMeth)
        return QSqlQueryModel::flags(a0);

    typedef Qt::ItemFlags (*sipVH_QtCore_50)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_50)(sipModuleAPI_QtSql_QtCore->em_virthandlers[50]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlQueryModel::removeRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[14],sipPySelf,NULL,sipName_removeRows);

    if (!sipMeth)
        return QSqlQueryModel::removeRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlQueryModel::insertRows(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,NULL,sipName_insertRows);

    if (!sipMeth)
        return QSqlQueryModel::insertRows(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

Qt::DropActions sipQSqlQueryModel::supportedDropActions() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[16]),sipPySelf,NULL,sipName_supportedDropActions);

    if (!sipMeth)
        return QSqlQueryModel::supportedDropActions();

    typedef Qt::DropActions (*sipVH_QtCore_53)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_53)(sipModuleAPI_QtSql_QtCore->em_virthandlers[53]))(sipGILState, 0, sipPySelf, sipMeth);
}

QMimeData* sipQSqlQueryModel::mimeData(const QModelIndexList& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[17]),sipPySelf,NULL,sipName_mimeData);

    if (!sipMeth)
        return QSqlQueryModel::mimeData(a0);

    typedef QMimeData* (*sipVH_QtCore_54)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QList<QModelIndex>&);

    return ((sipVH_QtCore_54)(sipModuleAPI_QtSql_QtCore->em_virthandlers[54]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QStringList sipQSqlQueryModel::mimeTypes() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[18]),sipPySelf,NULL,sipName_mimeTypes);

    if (!sipMeth)
        return QSqlQueryModel::mimeTypes();

    typedef QStringList (*sipVH_QtCore_27)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_27)(sipModuleAPI_QtSql_QtCore->em_virthandlers[27]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlQueryModel::setItemData(const QModelIndex& a0,const QMap<int,QVariant>& a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[19],sipPySelf,NULL,sipName_setItemData);

    if (!sipMeth)
        return QSqlQueryModel::setItemData(a0,a1);

    typedef bool (*sipVH_QtCore_55)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,const QMap<int,QVariant>&);

    return ((sipVH_QtCore_55)(sipModuleAPI_QtSql_QtCore->em_virthandlers[55]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QMap<int,QVariant> sipQSqlQueryModel::itemData(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[20]),sipPySelf,NULL,sipName_itemData);

    if (!sipMeth)
        return QSqlQueryModel::itemData(a0);

    typedef QMap<int,QVariant> (*sipVH_QtCore_56)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_56)(sipModuleAPI_QtSql_QtCore->em_virthandlers[56]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlQueryModel::setData(const QModelIndex& a0,const QVariant& a1,int a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,NULL,sipName_setData);

    if (!sipMeth)
        return QSqlQueryModel::setData(a0,a1,a2);

    typedef bool (*sipVH_QtCore_59)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,const QVariant&,int);

    return ((sipVH_QtCore_59)(sipModuleAPI_QtSql_QtCore->em_virthandlers[59]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlQueryModel::dropMimeData(const QMimeData*a0,Qt::DropAction a1,int a2,int a3,const QModelIndex& a4)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[22],sipPySelf,NULL,sipName_dropMimeData);

    if (!sipMeth)
        return QSqlQueryModel::dropMimeData(a0,a1,a2,a3,a4);

    typedef bool (*sipVH_QtCore_45)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QMimeData*,Qt::DropAction,int,int,const QModelIndex&);

    return ((sipVH_QtCore_45)(sipModuleAPI_QtSql_QtCore->em_virthandlers[45]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3, a4);
}

QModelIndex sipQSqlQueryModel::index(int a0,int a1,const QModelIndex& a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[23]),sipPySelf,NULL,sipName_index);

    if (!sipMeth)
        return QSqlQueryModel::index(a0,a1,a2);

    typedef QModelIndex (*sipVH_QtCore_46)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_46)(sipModuleAPI_QtSql_QtCore->em_virthandlers[46]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

void sipQSqlQueryModel::queryChange()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[24],sipPySelf,NULL,sipName_queryChange);

    if (!sipMeth)
    {
        QSqlQueryModel::queryChange();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlQueryModel::canFetchMore(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[25]),sipPySelf,NULL,sipName_canFetchMore);

    if (!sipMeth)
        return QSqlQueryModel::canFetchMore(a0);

    typedef bool (*sipVH_QtCore_42)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_42)(sipModuleAPI_QtSql_QtCore->em_virthandlers[42]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::fetchMore(const QModelIndex& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[26],sipPySelf,NULL,sipName_fetchMore);

    if (!sipMeth)
    {
        QSqlQueryModel::fetchMore(a0);
        return;
    }

    typedef void (*sipVH_QtCore_51)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    ((sipVH_QtCore_51)(sipModuleAPI_QtSql_QtCore->em_virthandlers[51]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlQueryModel::clear()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[27],sipPySelf,NULL,sipName_clear);

    if (!sipMeth)
    {
        QSqlQueryModel::clear();
        return;
    }

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlQueryModel::removeColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[28],sipPySelf,NULL,sipName_removeColumns);

    if (!sipMeth)
        return QSqlQueryModel::removeColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlQueryModel::insertColumns(int a0,int a1,const QModelIndex& a2)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[29],sipPySelf,NULL,sipName_insertColumns);

    if (!sipMeth)
        return QSqlQueryModel::insertColumns(a0,a1,a2);

    typedef bool (*sipVH_QtCore_52)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int,const QModelIndex&);

    return ((sipVH_QtCore_52)(sipModuleAPI_QtSql_QtCore->em_virthandlers[52]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

bool sipQSqlQueryModel::setHeaderData(int a0,Qt::Orientation a1,const QVariant& a2,int a3)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[30],sipPySelf,NULL,sipName_setHeaderData);

    if (!sipMeth)
        return QSqlQueryModel::setHeaderData(a0,a1,a2,a3);

    typedef bool (*sipVH_QtCore_57)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,const QVariant&,int);

    return ((sipVH_QtCore_57)(sipModuleAPI_QtSql_QtCore->em_virthandlers[57]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

QVariant sipQSqlQueryModel::headerData(int a0,Qt::Orientation a1,int a2) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[31]),sipPySelf,NULL,sipName_headerData);

    if (!sipMeth)
        return QSqlQueryModel::headerData(a0,a1,a2);

    typedef QVariant (*sipVH_QtCore_58)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,Qt::Orientation,int);

    return ((sipVH_QtCore_58)(sipModuleAPI_QtSql_QtCore->em_virthandlers[58]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2);
}

QVariant sipQSqlQueryModel::data(const QModelIndex& a0,int a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[32]),sipPySelf,NULL,sipName_data);

    if (!sipMeth)
        return QSqlQueryModel::data(a0,a1);

    typedef QVariant (*sipVH_QtCore_60)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&,int);

    return ((sipVH_QtCore_60)(sipModuleAPI_QtSql_QtCore->em_virthandlers[60]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

int sipQSqlQueryModel::columnCount(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[33]),sipPySelf,NULL,sipName_columnCount);

    if (!sipMeth)
        return QSqlQueryModel::columnCount(a0);

    typedef int (*sipVH_QtCore_43)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_43)(sipModuleAPI_QtSql_QtCore->em_virthandlers[43]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

int sipQSqlQueryModel::rowCount(const QModelIndex& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[34]),sipPySelf,NULL,sipName_rowCount);

    if (!sipMeth)
        return QSqlQueryModel::rowCount(a0);

    typedef int (*sipVH_QtCore_43)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QModelIndex&);

    return ((sipVH_QtCore_43)(sipModuleAPI_QtSql_QtCore->em_virthandlers[43]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QObject* sipQSqlQueryModel::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQSqlQueryModel::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQSqlQueryModel::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQSqlQueryModel::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQSqlQueryModel::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQSqlQueryModel::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQSqlQueryModel::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQSqlQueryModel::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

void sipQSqlQueryModel::sipProtect_resetInternalData()
{
    QAbstractItemModel::resetInternalData();
}

void sipQSqlQueryModel::sipProtect_encodeData(const QModelIndexList& a0,QDataStream& a1) const
{
    QAbstractItemModel::encodeData(a0,a1);
}

bool sipQSqlQueryModel::sipProtect_decodeData(int a0,int a1,const QModelIndex& a2,QDataStream& a3)
{
    return QAbstractItemModel::decodeData(a0,a1,a2,a3);
}

void sipQSqlQueryModel::sipProtect_beginInsertRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertRows(a0,a1,a2);
}

void sipQSqlQueryModel::sipProtect_endInsertRows()
{
    QAbstractItemModel::endInsertRows();
}

void sipQSqlQueryModel::sipProtect_beginRemoveRows(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveRows(a0,a1,a2);
}

void sipQSqlQueryModel::sipProtect_endRemoveRows()
{
    QAbstractItemModel::endRemoveRows();
}

void sipQSqlQueryModel::sipProtect_beginInsertColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginInsertColumns(a0,a1,a2);
}

void sipQSqlQueryModel::sipProtect_endInsertColumns()
{
    QAbstractItemModel::endInsertColumns();
}

void sipQSqlQueryModel::sipProtect_beginRemoveColumns(const QModelIndex& a0,int a1,int a2)
{
    QAbstractItemModel::beginRemoveColumns(a0,a1,a2);
}

void sipQSqlQueryModel::sipProtect_endRemoveColumns()
{
    QAbstractItemModel::endRemoveColumns();
}

QModelIndexList sipQSqlQueryModel::sipProtect_persistentIndexList() const
{
    return QAbstractItemModel::persistentIndexList();
}

void sipQSqlQueryModel::sipProtect_reset()
{
    QAbstractItemModel::reset();
}

void sipQSqlQueryModel::sipProtect_changePersistentIndex(const QModelIndex& a0,const QModelIndex& a1)
{
    QAbstractItemModel::changePersistentIndex(a0,a1);
}

void sipQSqlQueryModel::sipProtect_changePersistentIndexList(const QModelIndexList& a0,const QModelIndexList& a1)
{
    QAbstractItemModel::changePersistentIndexList(a0,a1);
}

QModelIndex sipQSqlQueryModel::sipProtect_createIndex(int a0,int a1,void*a2) const
{
    return QAbstractItemModel::createIndex(a0,a1,a2);
}

bool sipQSqlQueryModel::sipProtect_beginMoveRows(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveRows(a0,a1,a2,a3,a4);
}

void sipQSqlQueryModel::sipProtect_endMoveRows()
{
    QAbstractItemModel::endMoveRows();
}

bool sipQSqlQueryModel::sipProtect_beginMoveColumns(const QModelIndex& a0,int a1,int a2,const QModelIndex& a3,int a4)
{
    return QAbstractItemModel::beginMoveColumns(a0,a1,a2,a3,a4);
}

void sipQSqlQueryModel::sipProtect_endMoveColumns()
{
    QAbstractItemModel::endMoveColumns();
}

void sipQSqlQueryModel::sipProtect_beginResetModel()
{
    QAbstractItemModel::beginResetModel();
}

void sipQSqlQueryModel::sipProtect_endResetModel()
{
    QAbstractItemModel::endResetModel();
}

void sipQSqlQueryModel::sipProtect_setRoleNames(const QHash<int,QByteArray>& a0)
{
    QAbstractItemModel::setRoleNames(a0);
}

void sipQSqlQueryModel::sipProtectVirt_queryChange(bool sipSelfWasArg)
{
    (sipSelfWasArg ? QSqlQueryModel::queryChange() : queryChange());
}

QModelIndex sipQSqlQueryModel::sipProtect_indexInQuery(const QModelIndex& a0) const
{
    return QSqlQueryModel::indexInQuery(a0);
}

void sipQSqlQueryModel::sipProtect_setLastError(const QSqlError& a0)
{
    QSqlQueryModel::setLastError(a0);
}


PyDoc_STRVAR(doc_QSqlQueryModel_sender, "QSqlQueryModel.sender() -> QObject");

extern "C" {static PyObject *meth_QSqlQueryModel_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            QObject*sipRes = 0;

#line 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (helper)
            sipRes = helper(sipRes);
#line 12830 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_sender, doc_QSqlQueryModel_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_receivers, "QSqlQueryModel.receivers(SIGNAL()) -> int");

extern "C" {static PyObject *meth_QSqlQueryModel_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        char* a0;
        const sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 12875 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_receivers, doc_QSqlQueryModel_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_timerEvent, "QSqlQueryModel.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QSqlQueryModel_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_timerEvent, doc_QSqlQueryModel_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_childEvent, "QSqlQueryModel.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QSqlQueryModel_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_childEvent, doc_QSqlQueryModel_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_customEvent, "QSqlQueryModel.customEvent(QEvent)");

extern "C" {static PyObject *meth_QSqlQueryModel_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_customEvent, doc_QSqlQueryModel_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_connectNotify, "QSqlQueryModel.connectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlQueryModel_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_connectNotify, doc_QSqlQueryModel_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_disconnectNotify, "QSqlQueryModel.disconnectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlQueryModel_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_disconnectNotify, doc_QSqlQueryModel_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_senderSignalIndex, "QSqlQueryModel.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QSqlQueryModel_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_senderSignalIndex, doc_QSqlQueryModel_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_resetInternalData, "QSqlQueryModel.resetInternalData()");

extern "C" {static PyObject *meth_QSqlQueryModel_resetInternalData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_resetInternalData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_resetInternalData();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_resetInternalData, doc_QSqlQueryModel_resetInternalData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_encodeData, "QSqlQueryModel.encodeData(list-of-QModelIndex, QDataStream)");

extern "C" {static PyObject *meth_QSqlQueryModel_encodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_encodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        QDataStream* a1;
        const sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QDataStream, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_encodeData(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_encodeData, doc_QSqlQueryModel_encodeData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_decodeData, "QSqlQueryModel.decodeData(int, int, QModelIndex, QDataStream) -> bool");

extern "C" {static PyObject *meth_QSqlQueryModel_decodeData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_decodeData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        const QModelIndex* a2;
        QDataStream* a3;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BiiJ9J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2, sipType_QDataStream, &a3))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_decodeData(a0,a1,*a2,*a3);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_decodeData, doc_QSqlQueryModel_decodeData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_beginInsertRows, "QSqlQueryModel.beginInsertRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlQueryModel_beginInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_beginInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginInsertRows(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_beginInsertRows, doc_QSqlQueryModel_beginInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_endInsertRows, "QSqlQueryModel.endInsertRows()");

extern "C" {static PyObject *meth_QSqlQueryModel_endInsertRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_endInsertRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endInsertRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_endInsertRows, doc_QSqlQueryModel_endInsertRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_beginRemoveRows, "QSqlQueryModel.beginRemoveRows(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlQueryModel_beginRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_beginRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginRemoveRows(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_beginRemoveRows, doc_QSqlQueryModel_beginRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_endRemoveRows, "QSqlQueryModel.endRemoveRows()");

extern "C" {static PyObject *meth_QSqlQueryModel_endRemoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_endRemoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endRemoveRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_endRemoveRows, doc_QSqlQueryModel_endRemoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_beginInsertColumns, "QSqlQueryModel.beginInsertColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlQueryModel_beginInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_beginInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginInsertColumns(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_beginInsertColumns, doc_QSqlQueryModel_beginInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_endInsertColumns, "QSqlQueryModel.endInsertColumns()");

extern "C" {static PyObject *meth_QSqlQueryModel_endInsertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_endInsertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endInsertColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_endInsertColumns, doc_QSqlQueryModel_endInsertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_beginRemoveColumns, "QSqlQueryModel.beginRemoveColumns(QModelIndex, int, int)");

extern "C" {static PyObject *meth_QSqlQueryModel_beginRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_beginRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9ii", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginRemoveColumns(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_beginRemoveColumns, doc_QSqlQueryModel_beginRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_endRemoveColumns, "QSqlQueryModel.endRemoveColumns()");

extern "C" {static PyObject *meth_QSqlQueryModel_endRemoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_endRemoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endRemoveColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_endRemoveColumns, doc_QSqlQueryModel_endRemoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_persistentIndexList, "QSqlQueryModel.persistentIndexList() -> list-of-QModelIndex");

extern "C" {static PyObject *meth_QSqlQueryModel_persistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_persistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            QModelIndexList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QModelIndexList(sipCpp->sipProtect_persistentIndexList());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0100QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_persistentIndexList, doc_QSqlQueryModel_persistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_reset, "QSqlQueryModel.reset()");

extern "C" {static PyObject *meth_QSqlQueryModel_reset(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_reset(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_reset();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_reset, doc_QSqlQueryModel_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_changePersistentIndex, "QSqlQueryModel.changePersistentIndex(QModelIndex, QModelIndex)");

extern "C" {static PyObject *meth_QSqlQueryModel_changePersistentIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_changePersistentIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const QModelIndex* a1;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, sipType_QModelIndex, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_changePersistentIndex(*a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_changePersistentIndex, doc_QSqlQueryModel_changePersistentIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_changePersistentIndexList, "QSqlQueryModel.changePersistentIndexList(list-of-QModelIndex, list-of-QModelIndex)");

extern "C" {static PyObject *meth_QSqlQueryModel_changePersistentIndexList(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_changePersistentIndexList(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndexList* a0;
        int a0State = 0;
        const QModelIndexList* a1;
        int a1State = 0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1J1", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QList_0100QModelIndex,&a0, &a0State, sipType_QList_0100QModelIndex,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_changePersistentIndexList(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QModelIndexList *>(a0),sipType_QList_0100QModelIndex,a0State);
            sipReleaseType(const_cast<QModelIndexList *>(a1),sipType_QList_0100QModelIndex,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_changePersistentIndexList, doc_QSqlQueryModel_changePersistentIndexList);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_createIndex, "QSqlQueryModel.createIndex(int, int, object object=0) -> QModelIndex");

extern "C" {static PyObject *meth_QSqlQueryModel_createIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_createIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        PyObject * a2 = 0;
        const sipQSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_object,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|P0", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0, &a1, &a2))
        {
            QModelIndex*sipRes = 0;

#line 243 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qabstractitemmodel.sip"
        // The Qt API is broken (and won't be fixed as it would break binary
        // compatibility) regarding the internal id of a model index on different
        // architectures (32 vs 64 bits).  We choose to work around the breakage as it
        // is fairly subtle and continues to catch people out.  Instead of letting Qt
        // convert betweed an integer id and a pointer id (the internal format used by
        // Qt) we let Python do it.
        
        void *ptr;
        
        if (a2)
        {
            // Try and convert it to a Python long and fallback to the object's
            // address if it fails.
            ptr = PyLong_AsVoidPtr(a2);
        
            if (PyErr_Occurred())
            {
                PyErr_Clear();
                ptr = a2;
            }
        }
        else
        {
            ptr = 0;
        }
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = new QModelIndex(sipCpp->createIndex(a0, a1, ptr));
        #else
        sipRes = new QModelIndex(sipCpp->sipProtect_createIndex(a0, a1, ptr));
        #endif
#line 13572 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromNewType(sipRes,sipType_QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_createIndex, doc_QSqlQueryModel_createIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_beginMoveRows, "QSqlQueryModel.beginMoveRows(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_QSqlQueryModel_beginMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_beginMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_beginMoveRows(*a0,a1,a2,*a3,a4);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_beginMoveRows, doc_QSqlQueryModel_beginMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_endMoveRows, "QSqlQueryModel.endMoveRows()");

extern "C" {static PyObject *meth_QSqlQueryModel_endMoveRows(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_endMoveRows(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endMoveRows();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_endMoveRows, doc_QSqlQueryModel_endMoveRows);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_beginMoveColumns, "QSqlQueryModel.beginMoveColumns(QModelIndex, int, int, QModelIndex, int) -> bool");

extern "C" {static PyObject *meth_QSqlQueryModel_beginMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_beginMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        int a1;
        int a2;
        const QModelIndex* a3;
        int a4;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9iiJ9i", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, &a1, &a2, sipType_QModelIndex, &a3, &a4))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_beginMoveColumns(*a0,a1,a2,*a3,a4);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_beginMoveColumns, doc_QSqlQueryModel_beginMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_endMoveColumns, "QSqlQueryModel.endMoveColumns()");

extern "C" {static PyObject *meth_QSqlQueryModel_endMoveColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_endMoveColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endMoveColumns();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_endMoveColumns, doc_QSqlQueryModel_endMoveColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_beginResetModel, "QSqlQueryModel.beginResetModel()");

extern "C" {static PyObject *meth_QSqlQueryModel_beginResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_beginResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_beginResetModel();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_beginResetModel, doc_QSqlQueryModel_beginResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_endResetModel, "QSqlQueryModel.endResetModel()");

extern "C" {static PyObject *meth_QSqlQueryModel_endResetModel(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_endResetModel(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_endResetModel();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_endResetModel, doc_QSqlQueryModel_endResetModel);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_setRoleNames, "QSqlQueryModel.setRoleNames(dict-of-int-QByteArray)");

extern "C" {static PyObject *meth_QSqlQueryModel_setRoleNames(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_setRoleNames(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QHash<int,QByteArray>* a0;
        int a0State = 0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QHash_1800_0100QByteArray,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setRoleNames(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QHash<int,QByteArray> *>(a0),sipType_QHash_1800_0100QByteArray,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_setRoleNames, doc_QSqlQueryModel_setRoleNames);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_rowCount, "QSqlQueryModel.rowCount(QModelIndex parent=QModelIndex()) -> int");

extern "C" {static PyObject *meth_QSqlQueryModel_rowCount(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_rowCount(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex& a0def = QModelIndex();
        const QModelIndex* a0 = &a0def;
        const QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlQueryModel::rowCount(*a0) : sipCpp->rowCount(*a0));
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_rowCount, doc_QSqlQueryModel_rowCount);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_columnCount, "QSqlQueryModel.columnCount(QModelIndex parent=QModelIndex()) -> int");

extern "C" {static PyObject *meth_QSqlQueryModel_columnCount(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_columnCount(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex& a0def = QModelIndex();
        const QModelIndex* a0 = &a0def;
        const QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlQueryModel::columnCount(*a0) : sipCpp->columnCount(*a0));
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_columnCount, doc_QSqlQueryModel_columnCount);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_record, "QSqlQueryModel.record(int) -> QSqlRecord\n"
    "QSqlQueryModel.record() -> QSqlRecord");

extern "C" {static PyObject *meth_QSqlQueryModel_record(PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_record(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlQueryModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0))
        {
            QSqlRecord*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlRecord(sipCpp->record(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlRecord,NULL);
        }
    }

    {
        const QSqlQueryModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            QSqlRecord*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlRecord(sipCpp->record());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlRecord,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_record, doc_QSqlQueryModel_record);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_data, "QSqlQueryModel.data(QModelIndex, int role=Qt.DisplayRole) -> object");

extern "C" {static PyObject *meth_QSqlQueryModel_data(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_data(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex* a0;
        int a1 = Qt::DisplayRole;
        const QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|i", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0, &a1))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant((sipSelfWasArg ? sipCpp->QSqlQueryModel::data(*a0,a1) : sipCpp->data(*a0,a1)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_data, doc_QSqlQueryModel_data);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_headerData, "QSqlQueryModel.headerData(int, Qt.Orientation, int role=Qt.DisplayRole) -> object");

extern "C" {static PyObject *meth_QSqlQueryModel_headerData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_headerData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        Qt::Orientation a1;
        int a2 = Qt::DisplayRole;
        const QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiE|i", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0, sipType_Qt_Orientation, &a1, &a2))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant((sipSelfWasArg ? sipCpp->QSqlQueryModel::headerData(a0,a1,a2) : sipCpp->headerData(a0,a1,a2)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_headerData, doc_QSqlQueryModel_headerData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_setHeaderData, "QSqlQueryModel.setHeaderData(int, Qt.Orientation, object, int role=Qt.EditRole) -> bool");

extern "C" {static PyObject *meth_QSqlQueryModel_setHeaderData(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_setHeaderData(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        Qt::Orientation a1;
        const QVariant* a2;
        int a2State = 0;
        int a3 = Qt::EditRole;
        QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            sipName_role,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiEJ1|i", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0, sipType_Qt_Orientation, &a1, sipType_QVariant,&a2, &a2State, &a3))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlQueryModel::setHeaderData(a0,a1,*a2,a3) : sipCpp->setHeaderData(a0,a1,*a2,a3));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a2),sipType_QVariant,a2State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_setHeaderData, doc_QSqlQueryModel_setHeaderData);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_insertColumns, "QSqlQueryModel.insertColumns(int, int, QModelIndex parent=QModelIndex()) -> bool");

extern "C" {static PyObject *meth_QSqlQueryModel_insertColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_insertColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        const QModelIndex& a2def = QModelIndex();
        const QModelIndex* a2 = &a2def;
        QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlQueryModel::insertColumns(a0,a1,*a2) : sipCpp->insertColumns(a0,a1,*a2));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_insertColumns, doc_QSqlQueryModel_insertColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_removeColumns, "QSqlQueryModel.removeColumns(int, int, QModelIndex parent=QModelIndex()) -> bool");

extern "C" {static PyObject *meth_QSqlQueryModel_removeColumns(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_removeColumns(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        const QModelIndex& a2def = QModelIndex();
        const QModelIndex* a2 = &a2def;
        QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bii|J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, &a0, &a1, sipType_QModelIndex, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlQueryModel::removeColumns(a0,a1,*a2) : sipCpp->removeColumns(a0,a1,*a2));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_removeColumns, doc_QSqlQueryModel_removeColumns);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_setQuery, "QSqlQueryModel.setQuery(QSqlQuery)\n"
    "QSqlQueryModel.setQuery(str, QSqlDatabase db=QSqlDatabase())");

extern "C" {static PyObject *meth_QSqlQueryModel_setQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_setQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery* a0;
        QSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QSqlQuery, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setQuery(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QSqlDatabase& a1def = QSqlDatabase();
        const QSqlDatabase* a1 = &a1def;
        QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_db,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QString,&a0, &a0State, sipType_QSqlDatabase, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setQuery(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_setQuery, doc_QSqlQueryModel_setQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_query, "QSqlQueryModel.query() -> QSqlQuery");

extern "C" {static PyObject *meth_QSqlQueryModel_query(PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_query(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQueryModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            QSqlQuery*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlQuery(sipCpp->query());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlQuery,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_query, doc_QSqlQueryModel_query);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_clear, "QSqlQueryModel.clear()");

extern "C" {static PyObject *meth_QSqlQueryModel_clear(PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_clear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlQueryModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlQueryModel::clear() : sipCpp->clear());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_clear, doc_QSqlQueryModel_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_lastError, "QSqlQueryModel.lastError() -> QSqlError");

extern "C" {static PyObject *meth_QSqlQueryModel_lastError(PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_lastError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQueryModel *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            QSqlError*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlError(sipCpp->lastError());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlError,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_lastError, doc_QSqlQueryModel_lastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_fetchMore, "QSqlQueryModel.fetchMore(QModelIndex parent=QModelIndex())");

extern "C" {static PyObject *meth_QSqlQueryModel_fetchMore(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_fetchMore(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex& a0def = QModelIndex();
        const QModelIndex* a0 = &a0def;
        QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp->QSqlQueryModel::fetchMore(*a0) : sipCpp->fetchMore(*a0));
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_fetchMore, doc_QSqlQueryModel_fetchMore);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_canFetchMore, "QSqlQueryModel.canFetchMore(QModelIndex parent=QModelIndex()) -> bool");

extern "C" {static PyObject *meth_QSqlQueryModel_canFetchMore(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_canFetchMore(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QModelIndex& a0def = QModelIndex();
        const QModelIndex* a0 = &a0def;
        const QSqlQueryModel *sipCpp;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlQueryModel::canFetchMore(*a0) : sipCpp->canFetchMore(*a0));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_canFetchMore, doc_QSqlQueryModel_canFetchMore);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_queryChange, "QSqlQueryModel.queryChange()");

extern "C" {static PyObject *meth_QSqlQueryModel_queryChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_queryChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlQueryModel, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_queryChange(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_queryChange, doc_QSqlQueryModel_queryChange);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_indexInQuery, "QSqlQueryModel.indexInQuery(QModelIndex) -> QModelIndex");

extern "C" {static PyObject *meth_QSqlQueryModel_indexInQuery(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_indexInQuery(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QModelIndex* a0;
        const sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QModelIndex, &a0))
        {
            QModelIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QModelIndex(sipCpp->sipProtect_indexInQuery(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QModelIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_indexInQuery, doc_QSqlQueryModel_indexInQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQueryModel_setLastError, "QSqlQueryModel.setLastError(QSqlError)");

extern "C" {static PyObject *meth_QSqlQueryModel_setLastError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQueryModel_setLastError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError* a0;
        sipQSqlQueryModel *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlQueryModel, &sipCpp, sipType_QSqlError, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setLastError(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQueryModel, sipName_setLastError, doc_QSqlQueryModel_setLastError);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlQueryModel(void *, const sipTypeDef *);}
static void *cast_QSqlQueryModel(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSqlQueryModel)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QAbstractTableModel)->ctd_cast((QAbstractTableModel *)(QSqlQueryModel *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlQueryModel(void *, int);}
static void release_QSqlQueryModel(void *sipCppV,int)
{
    QSqlQueryModel *sipCpp = reinterpret_cast<QSqlQueryModel *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSqlQueryModel(sipSimpleWrapper *);}
static void dealloc_QSqlQueryModel(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlQueryModel *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlQueryModel(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlQueryModel(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlQueryModel(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQSqlQueryModel *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlQueryModel(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSqlQueryModel[] = {{16, 0, 1}};


static PyMethodDef methods_QSqlQueryModel[] = {
    {SIP_MLNAME_CAST(sipName_beginInsertColumns), (PyCFunction)meth_QSqlQueryModel_beginInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginInsertRows), (PyCFunction)meth_QSqlQueryModel_beginInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveColumns), (PyCFunction)meth_QSqlQueryModel_beginMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginMoveRows), (PyCFunction)meth_QSqlQueryModel_beginMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveColumns), (PyCFunction)meth_QSqlQueryModel_beginRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginRemoveRows), (PyCFunction)meth_QSqlQueryModel_beginRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_beginResetModel), (PyCFunction)meth_QSqlQueryModel_beginResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_canFetchMore), (PyCFunction)meth_QSqlQueryModel_canFetchMore, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_canFetchMore)},
    {SIP_MLNAME_CAST(sipName_changePersistentIndex), (PyCFunction)meth_QSqlQueryModel_changePersistentIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_changePersistentIndexList), (PyCFunction)meth_QSqlQueryModel_changePersistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QSqlQueryModel_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_clear), meth_QSqlQueryModel_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQueryModel_clear)},
    {SIP_MLNAME_CAST(sipName_columnCount), (PyCFunction)meth_QSqlQueryModel_columnCount, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_columnCount)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QSqlQueryModel_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createIndex), (PyCFunction)meth_QSqlQueryModel_createIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QSqlQueryModel_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_data), (PyCFunction)meth_QSqlQueryModel_data, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_data)},
    {SIP_MLNAME_CAST(sipName_decodeData), (PyCFunction)meth_QSqlQueryModel_decodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QSqlQueryModel_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_encodeData), (PyCFunction)meth_QSqlQueryModel_encodeData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertColumns), (PyCFunction)meth_QSqlQueryModel_endInsertColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endInsertRows), (PyCFunction)meth_QSqlQueryModel_endInsertRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveColumns), (PyCFunction)meth_QSqlQueryModel_endMoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endMoveRows), (PyCFunction)meth_QSqlQueryModel_endMoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveColumns), (PyCFunction)meth_QSqlQueryModel_endRemoveColumns, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endRemoveRows), (PyCFunction)meth_QSqlQueryModel_endRemoveRows, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_endResetModel), (PyCFunction)meth_QSqlQueryModel_endResetModel, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_fetchMore), (PyCFunction)meth_QSqlQueryModel_fetchMore, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_fetchMore)},
    {SIP_MLNAME_CAST(sipName_headerData), (PyCFunction)meth_QSqlQueryModel_headerData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_headerData)},
    {SIP_MLNAME_CAST(sipName_indexInQuery), (PyCFunction)meth_QSqlQueryModel_indexInQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_indexInQuery)},
    {SIP_MLNAME_CAST(sipName_insertColumns), (PyCFunction)meth_QSqlQueryModel_insertColumns, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_insertColumns)},
    {SIP_MLNAME_CAST(sipName_lastError), meth_QSqlQueryModel_lastError, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQueryModel_lastError)},
    {SIP_MLNAME_CAST(sipName_persistentIndexList), (PyCFunction)meth_QSqlQueryModel_persistentIndexList, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_query), meth_QSqlQueryModel_query, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQueryModel_query)},
    {SIP_MLNAME_CAST(sipName_queryChange), (PyCFunction)meth_QSqlQueryModel_queryChange, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_queryChange)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QSqlQueryModel_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_record), meth_QSqlQueryModel_record, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQueryModel_record)},
    {SIP_MLNAME_CAST(sipName_removeColumns), (PyCFunction)meth_QSqlQueryModel_removeColumns, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_removeColumns)},
    {SIP_MLNAME_CAST(sipName_reset), (PyCFunction)meth_QSqlQueryModel_reset, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_resetInternalData), (PyCFunction)meth_QSqlQueryModel_resetInternalData, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_rowCount), (PyCFunction)meth_QSqlQueryModel_rowCount, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_rowCount)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QSqlQueryModel_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QSqlQueryModel_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setHeaderData), (PyCFunction)meth_QSqlQueryModel_setHeaderData, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_setHeaderData)},
    {SIP_MLNAME_CAST(sipName_setLastError), (PyCFunction)meth_QSqlQueryModel_setLastError, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_setLastError)},
    {SIP_MLNAME_CAST(sipName_setQuery), (PyCFunction)meth_QSqlQueryModel_setQuery, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQueryModel_setQuery)},
    {SIP_MLNAME_CAST(sipName_setRoleNames), (PyCFunction)meth_QSqlQueryModel_setRoleNames, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QSqlQueryModel_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QSqlQueryModel, "\1QSqlQueryModel(QObject parent=None)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlQueryModel = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QSqlQueryModel,
        {0}
    },
    {
        sipNameNr_QSqlQueryModel,
        {0, 0, 1},
        48, methods_QSqlQueryModel,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlQueryModel,
    -1,
    -1,
    supers_QSqlQueryModel,
    0,
    init_type_QSqlQueryModel,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlQueryModel,
    0,
    0,
    0,
    release_QSqlQueryModel,
    cast_QSqlQueryModel,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QSqlQueryModel::staticMetaObject,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlquery.sip"
#include <qsqlquery.h>
#line 14601 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlresult.sip"
#include <qsqlresult.h>
#line 14605 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 14608 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 14611 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 14614 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 14617 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qmap.sip"
#include <qmap.h>
#line 14620 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 72 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 14623 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 14626 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 14629 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 14632 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldriver.sip"
#include <qsqldriver.h>
#line 14635 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 14638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


PyDoc_STRVAR(doc_QSqlQuery_isValid, "QSqlQuery.isValid() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_isValid(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_isValid, doc_QSqlQuery_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_isActive, "QSqlQuery.isActive() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_isActive(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_isActive(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isActive();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_isActive, doc_QSqlQuery_isActive);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_isNull, "QSqlQuery.isNull(int) -> bool");

extern "C" {static PyObject *meth_QSqlQuery_isNull(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlQuery, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_isNull, doc_QSqlQuery_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_at, "QSqlQuery.at() -> int");

extern "C" {static PyObject *meth_QSqlQuery_at(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_at(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->at();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_at, doc_QSqlQuery_at);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_lastQuery, "QSqlQuery.lastQuery() -> str");

extern "C" {static PyObject *meth_QSqlQuery_lastQuery(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_lastQuery(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->lastQuery());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_lastQuery, doc_QSqlQuery_lastQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_numRowsAffected, "QSqlQuery.numRowsAffected() -> int");

extern "C" {static PyObject *meth_QSqlQuery_numRowsAffected(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_numRowsAffected(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->numRowsAffected();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_numRowsAffected, doc_QSqlQuery_numRowsAffected);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_lastError, "QSqlQuery.lastError() -> QSqlError");

extern "C" {static PyObject *meth_QSqlQuery_lastError(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_lastError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            QSqlError*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlError(sipCpp->lastError());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlError,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_lastError, doc_QSqlQuery_lastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_isSelect, "QSqlQuery.isSelect() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_isSelect(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_isSelect(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isSelect();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_isSelect, doc_QSqlQuery_isSelect);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_size, "QSqlQuery.size() -> int");

extern "C" {static PyObject *meth_QSqlQuery_size(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_size(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->size();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_size, doc_QSqlQuery_size);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_driver, "QSqlQuery.driver() -> QSqlDriver");

extern "C" {static PyObject *meth_QSqlQuery_driver(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_driver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            const QSqlDriver*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->driver();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QSqlDriver *>(sipRes),sipType_QSqlDriver,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_driver, doc_QSqlQuery_driver);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_result, "QSqlQuery.result() -> QSqlResult");

extern "C" {static PyObject *meth_QSqlQuery_result(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_result(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            const QSqlResult*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->result();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast<QSqlResult *>(sipRes),sipType_QSqlResult,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_result, doc_QSqlQuery_result);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_isForwardOnly, "QSqlQuery.isForwardOnly() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_isForwardOnly(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_isForwardOnly(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isForwardOnly();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_isForwardOnly, doc_QSqlQuery_isForwardOnly);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_record, "QSqlQuery.record() -> QSqlRecord");

extern "C" {static PyObject *meth_QSqlQuery_record(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_record(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            QSqlRecord*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlRecord(sipCpp->record());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlRecord,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_record, doc_QSqlQuery_record);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_setForwardOnly, "QSqlQuery.setForwardOnly(bool)");

extern "C" {static PyObject *meth_QSqlQuery_setForwardOnly(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_setForwardOnly(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QSqlQuery, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setForwardOnly(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_setForwardOnly, doc_QSqlQuery_setForwardOnly);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_exec_, "QSqlQuery.exec_(str) -> bool\n"
    "QSqlQuery.exec_() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_exec_(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_exec_(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->exec(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->exec();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_exec_, doc_QSqlQuery_exec_);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_exec, "QSqlQuery.exec(str) -> bool");

extern "C" {static PyObject *meth_QSqlQuery_exec(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_exec(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->exec(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_exec, doc_QSqlQuery_exec);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_value, "QSqlQuery.value(int) -> object");

extern "C" {static PyObject *meth_QSqlQuery_value(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_value(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlQuery, &sipCpp, &a0))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->value(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_value, doc_QSqlQuery_value);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_seek, "QSqlQuery.seek(int, bool relative=False) -> bool");

extern "C" {static PyObject *meth_QSqlQuery_seek(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_seek(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        bool a1 = 0;
        QSqlQuery *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_relative,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Bi|b", &sipSelf, sipType_QSqlQuery, &sipCpp, &a0, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->seek(a0,a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_seek, doc_QSqlQuery_seek);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_next, "QSqlQuery.next() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_next(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_next(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->next();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_next, doc_QSqlQuery_next);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_previous, "QSqlQuery.previous() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_previous(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_previous(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->previous();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_previous, doc_QSqlQuery_previous);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_first, "QSqlQuery.first() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_first(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_first(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->first();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_first, doc_QSqlQuery_first);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_last, "QSqlQuery.last() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_last(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_last(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->last();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_last, doc_QSqlQuery_last);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_clear, "QSqlQuery.clear()");

extern "C" {static PyObject *meth_QSqlQuery_clear(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_clear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->clear();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_clear, doc_QSqlQuery_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_execBatch, "QSqlQuery.execBatch(QSqlQuery.BatchExecutionMode mode=QSqlQuery.ValuesAsRows) -> bool");

extern "C" {static PyObject *meth_QSqlQuery_execBatch(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_execBatch(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery::BatchExecutionMode a0 = QSqlQuery::ValuesAsRows;
        QSqlQuery *sipCpp;

        static const char *sipKwdList[] = {
            sipName_mode,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|E", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QSqlQuery_BatchExecutionMode, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->execBatch(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_execBatch, doc_QSqlQuery_execBatch);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_prepare, "QSqlQuery.prepare(str) -> bool");

extern "C" {static PyObject *meth_QSqlQuery_prepare(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_prepare(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->prepare(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_prepare, doc_QSqlQuery_prepare);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_bindValue, "QSqlQuery.bindValue(str, object, QSql.ParamType type=QSql.In)\n"
    "QSqlQuery.bindValue(int, object, QSql.ParamType type=QSql.In)");

extern "C" {static PyObject *meth_QSqlQuery_bindValue(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_bindValue(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QVariant* a1;
        int a1State = 0;
        QSql::ParamType a2def = QSql::In;
        QSql::ParamType* a2 = &a2def;
        int a2State = 0;
        QSqlQuery *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_type,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1J1|J1", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant,&a1, &a1State, sipType_QSql_ParamType, &a2, &a2State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindValue(*a0,*a1,*a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);
            sipReleaseType(a2,sipType_QSql_ParamType,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const QVariant* a1;
        int a1State = 0;
        QSql::ParamType a2def = QSql::In;
        QSql::ParamType* a2 = &a2def;
        int a2State = 0;
        QSqlQuery *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_type,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiJ1|J1", &sipSelf, sipType_QSqlQuery, &sipCpp, &a0, sipType_QVariant,&a1, &a1State, sipType_QSql_ParamType, &a2, &a2State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindValue(a0,*a1,*a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);
            sipReleaseType(a2,sipType_QSql_ParamType,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_bindValue, doc_QSqlQuery_bindValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_addBindValue, "QSqlQuery.addBindValue(object, QSql.ParamType type=QSql.In)");

extern "C" {static PyObject *meth_QSqlQuery_addBindValue(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_addBindValue(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QVariant* a0;
        int a0State = 0;
        QSql::ParamType a1def = QSql::In;
        QSql::ParamType* a1 = &a1def;
        int a1State = 0;
        QSqlQuery *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_type,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J1", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QVariant,&a0, &a0State, sipType_QSql_ParamType, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->addBindValue(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);
            sipReleaseType(a1,sipType_QSql_ParamType,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_addBindValue, doc_QSqlQuery_addBindValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_boundValue, "QSqlQuery.boundValue(str) -> object\n"
    "QSqlQuery.boundValue(int) -> object");

extern "C" {static PyObject *meth_QSqlQuery_boundValue(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_boundValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->boundValue(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    {
        int a0;
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlQuery, &sipCpp, &a0))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->boundValue(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_boundValue, doc_QSqlQuery_boundValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_boundValues, "QSqlQuery.boundValues() -> dict-of-QString-QVariant");

extern "C" {static PyObject *meth_QSqlQuery_boundValues(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_boundValues(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            QMap<QString,QVariant>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QMap<QString,QVariant>(sipCpp->boundValues());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QMap_0100QString_0100QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_boundValues, doc_QSqlQuery_boundValues);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_executedQuery, "QSqlQuery.executedQuery() -> str");

extern "C" {static PyObject *meth_QSqlQuery_executedQuery(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_executedQuery(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->executedQuery());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_executedQuery, doc_QSqlQuery_executedQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_lastInsertId, "QSqlQuery.lastInsertId() -> object");

extern "C" {static PyObject *meth_QSqlQuery_lastInsertId(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_lastInsertId(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->lastInsertId());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_lastInsertId, doc_QSqlQuery_lastInsertId);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_setNumericalPrecisionPolicy, "QSqlQuery.setNumericalPrecisionPolicy(QSql.NumericalPrecisionPolicy)");

extern "C" {static PyObject *meth_QSqlQuery_setNumericalPrecisionPolicy(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_setNumericalPrecisionPolicy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::NumericalPrecisionPolicy a0;
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlQuery, &sipCpp, sipType_QSql_NumericalPrecisionPolicy, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNumericalPrecisionPolicy(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_setNumericalPrecisionPolicy, doc_QSqlQuery_setNumericalPrecisionPolicy);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_numericalPrecisionPolicy, "QSqlQuery.numericalPrecisionPolicy() -> QSql.NumericalPrecisionPolicy");

extern "C" {static PyObject *meth_QSqlQuery_numericalPrecisionPolicy(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_numericalPrecisionPolicy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            QSql::NumericalPrecisionPolicy sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->numericalPrecisionPolicy();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QSql_NumericalPrecisionPolicy);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_numericalPrecisionPolicy, doc_QSqlQuery_numericalPrecisionPolicy);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_finish, "QSqlQuery.finish()");

extern "C" {static PyObject *meth_QSqlQuery_finish(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_finish(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->finish();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_finish, doc_QSqlQuery_finish);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlQuery_nextResult, "QSqlQuery.nextResult() -> bool");

extern "C" {static PyObject *meth_QSqlQuery_nextResult(PyObject *, PyObject *);}
static PyObject *meth_QSqlQuery_nextResult(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlQuery *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlQuery, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->nextResult();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlQuery, sipName_nextResult, doc_QSqlQuery_nextResult);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlQuery(void *, const sipTypeDef *);}
static void *cast_QSqlQuery(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlQuery)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlQuery(void *, int);}
static void release_QSqlQuery(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSqlQuery *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSqlQuery(void *, SIP_SSIZE_T, const void *);}
static void assign_QSqlQuery(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSqlQuery *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSqlQuery *>(sipSrc);
}


extern "C" {static void *array_QSqlQuery(SIP_SSIZE_T);}
static void *array_QSqlQuery(SIP_SSIZE_T sipNrElem)
{
    return new QSqlQuery[sipNrElem];
}


extern "C" {static void *copy_QSqlQuery(const void *, SIP_SSIZE_T);}
static void *copy_QSqlQuery(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSqlQuery(reinterpret_cast<const QSqlQuery *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSqlQuery(sipSimpleWrapper *);}
static void dealloc_QSqlQuery(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlQuery(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSqlQuery(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlQuery(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSqlQuery *sipCpp = 0;

    {
        QSqlResult* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8", sipType_QSqlResult, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlQuery(a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;
        QSqlDatabase a1def = QSqlDatabase();
        QSqlDatabase* a1 = &a1def;

        static const char *sipKwdList[] = {
            sipName_query,
            sipName_db,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|J1J9", sipType_QString,&a0, &a0State, sipType_QSqlDatabase, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlQuery(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipCpp;
        }
    }

    {
        QSqlDatabase* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlDatabase, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlQuery(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QSqlQuery* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlQuery, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlQuery(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QSqlQuery[] = {
    {SIP_MLNAME_CAST(sipName_addBindValue), (PyCFunction)meth_QSqlQuery_addBindValue, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQuery_addBindValue)},
    {SIP_MLNAME_CAST(sipName_at), meth_QSqlQuery_at, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_at)},
    {SIP_MLNAME_CAST(sipName_bindValue), (PyCFunction)meth_QSqlQuery_bindValue, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQuery_bindValue)},
    {SIP_MLNAME_CAST(sipName_boundValue), meth_QSqlQuery_boundValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_boundValue)},
    {SIP_MLNAME_CAST(sipName_boundValues), meth_QSqlQuery_boundValues, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_boundValues)},
    {SIP_MLNAME_CAST(sipName_clear), meth_QSqlQuery_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_clear)},
    {SIP_MLNAME_CAST(sipName_driver), meth_QSqlQuery_driver, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_driver)},
    {SIP_MLNAME_CAST(sipName_exec), meth_QSqlQuery_exec, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_exec)},
    {SIP_MLNAME_CAST(sipName_execBatch), (PyCFunction)meth_QSqlQuery_execBatch, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQuery_execBatch)},
    {SIP_MLNAME_CAST(sipName_exec_), meth_QSqlQuery_exec_, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_exec_)},
    {SIP_MLNAME_CAST(sipName_executedQuery), meth_QSqlQuery_executedQuery, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_executedQuery)},
    {SIP_MLNAME_CAST(sipName_finish), meth_QSqlQuery_finish, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_finish)},
    {SIP_MLNAME_CAST(sipName_first), meth_QSqlQuery_first, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_first)},
    {SIP_MLNAME_CAST(sipName_isActive), meth_QSqlQuery_isActive, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_isActive)},
    {SIP_MLNAME_CAST(sipName_isForwardOnly), meth_QSqlQuery_isForwardOnly, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_isForwardOnly)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QSqlQuery_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_isNull)},
    {SIP_MLNAME_CAST(sipName_isSelect), meth_QSqlQuery_isSelect, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_isSelect)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QSqlQuery_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_isValid)},
    {SIP_MLNAME_CAST(sipName_last), meth_QSqlQuery_last, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_last)},
    {SIP_MLNAME_CAST(sipName_lastError), meth_QSqlQuery_lastError, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_lastError)},
    {SIP_MLNAME_CAST(sipName_lastInsertId), meth_QSqlQuery_lastInsertId, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_lastInsertId)},
    {SIP_MLNAME_CAST(sipName_lastQuery), meth_QSqlQuery_lastQuery, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_lastQuery)},
    {SIP_MLNAME_CAST(sipName_next), meth_QSqlQuery_next, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_next)},
    {SIP_MLNAME_CAST(sipName_nextResult), meth_QSqlQuery_nextResult, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_nextResult)},
    {SIP_MLNAME_CAST(sipName_numRowsAffected), meth_QSqlQuery_numRowsAffected, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_numRowsAffected)},
    {SIP_MLNAME_CAST(sipName_numericalPrecisionPolicy), meth_QSqlQuery_numericalPrecisionPolicy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_numericalPrecisionPolicy)},
    {SIP_MLNAME_CAST(sipName_prepare), meth_QSqlQuery_prepare, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_prepare)},
    {SIP_MLNAME_CAST(sipName_previous), meth_QSqlQuery_previous, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_previous)},
    {SIP_MLNAME_CAST(sipName_record), meth_QSqlQuery_record, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_record)},
    {SIP_MLNAME_CAST(sipName_result), meth_QSqlQuery_result, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_result)},
    {SIP_MLNAME_CAST(sipName_seek), (PyCFunction)meth_QSqlQuery_seek, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlQuery_seek)},
    {SIP_MLNAME_CAST(sipName_setForwardOnly), meth_QSqlQuery_setForwardOnly, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_setForwardOnly)},
    {SIP_MLNAME_CAST(sipName_setNumericalPrecisionPolicy), meth_QSqlQuery_setNumericalPrecisionPolicy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_setNumericalPrecisionPolicy)},
    {SIP_MLNAME_CAST(sipName_size), meth_QSqlQuery_size, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_size)},
    {SIP_MLNAME_CAST(sipName_value), meth_QSqlQuery_value, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlQuery_value)}
};

static sipEnumMemberDef enummembers_QSqlQuery[] = {
    {sipName_ValuesAsColumns, static_cast<int>(QSqlQuery::ValuesAsColumns), 18},
    {sipName_ValuesAsRows, static_cast<int>(QSqlQuery::ValuesAsRows), 18},
};

PyDoc_STRVAR(doc_QSqlQuery, "\1QSqlQuery(QSqlResult)\n"
    "QSqlQuery(str query='', QSqlDatabase db=QSqlDatabase())\n"
    "QSqlQuery(QSqlDatabase)\n"
    "QSqlQuery(QSqlQuery)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlQuery = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSqlQuery,
        {0}
    },
    {
        sipNameNr_QSqlQuery,
        {0, 0, 1},
        35, methods_QSqlQuery,
        2, enummembers_QSqlQuery,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlQuery,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QSqlQuery,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlQuery,
    assign_QSqlQuery,
    array_QSqlQuery,
    copy_QSqlQuery,
    release_QSqlQuery,
    cast_QSqlQuery,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlindex.sip"
#include <qsqlindex.h>
#line 15998 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 16002 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlfield.sip"
#include <qsqlfield.h>
#line 16005 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 16008 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 16011 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


PyDoc_STRVAR(doc_QSqlIndex_setCursorName, "QSqlIndex.setCursorName(str)");

extern "C" {static PyObject *meth_QSqlIndex_setCursorName(PyObject *, PyObject *);}
static PyObject *meth_QSqlIndex_setCursorName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlIndex, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setCursorName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlIndex, sipName_setCursorName, doc_QSqlIndex_setCursorName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlIndex_cursorName, "QSqlIndex.cursorName() -> str");

extern "C" {static PyObject *meth_QSqlIndex_cursorName(PyObject *, PyObject *);}
static PyObject *meth_QSqlIndex_cursorName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlIndex, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->cursorName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlIndex, sipName_cursorName, doc_QSqlIndex_cursorName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlIndex_setName, "QSqlIndex.setName(str)");

extern "C" {static PyObject *meth_QSqlIndex_setName(PyObject *, PyObject *);}
static PyObject *meth_QSqlIndex_setName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlIndex, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlIndex, sipName_setName, doc_QSqlIndex_setName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlIndex_name, "QSqlIndex.name() -> str");

extern "C" {static PyObject *meth_QSqlIndex_name(PyObject *, PyObject *);}
static PyObject *meth_QSqlIndex_name(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlIndex, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->name());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlIndex, sipName_name, doc_QSqlIndex_name);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlIndex_append, "QSqlIndex.append(QSqlField)\n"
    "QSqlIndex.append(QSqlField, bool)");

extern "C" {static PyObject *meth_QSqlIndex_append(PyObject *, PyObject *);}
static PyObject *meth_QSqlIndex_append(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField* a0;
        QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSqlIndex, &sipCpp, sipType_QSqlField, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->append(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QSqlField* a0;
        bool a1;
        QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9b", &sipSelf, sipType_QSqlIndex, &sipCpp, sipType_QSqlField, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->append(*a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlIndex, sipName_append, doc_QSqlIndex_append);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlIndex_isDescending, "QSqlIndex.isDescending(int) -> bool");

extern "C" {static PyObject *meth_QSqlIndex_isDescending(PyObject *, PyObject *);}
static PyObject *meth_QSqlIndex_isDescending(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlIndex, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isDescending(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlIndex, sipName_isDescending, doc_QSqlIndex_isDescending);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlIndex_setDescending, "QSqlIndex.setDescending(int, bool)");

extern "C" {static PyObject *meth_QSqlIndex_setDescending(PyObject *, PyObject *);}
static PyObject *meth_QSqlIndex_setDescending(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        bool a1;
        QSqlIndex *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bib", &sipSelf, sipType_QSqlIndex, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDescending(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlIndex, sipName_setDescending, doc_QSqlIndex_setDescending);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlIndex(void *, const sipTypeDef *);}
static void *cast_QSqlIndex(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSqlIndex)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QSqlRecord)->ctd_cast((QSqlRecord *)(QSqlIndex *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlIndex(void *, int);}
static void release_QSqlIndex(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSqlIndex *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSqlIndex(void *, SIP_SSIZE_T, const void *);}
static void assign_QSqlIndex(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSqlIndex *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSqlIndex *>(sipSrc);
}


extern "C" {static void *array_QSqlIndex(SIP_SSIZE_T);}
static void *array_QSqlIndex(SIP_SSIZE_T sipNrElem)
{
    return new QSqlIndex[sipNrElem];
}


extern "C" {static void *copy_QSqlIndex(const void *, SIP_SSIZE_T);}
static void *copy_QSqlIndex(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSqlIndex(reinterpret_cast<const QSqlIndex *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSqlIndex(sipSimpleWrapper *);}
static void dealloc_QSqlIndex(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlIndex(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSqlIndex(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlIndex(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSqlIndex *sipCpp = 0;

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;
        const QString& a1def = QString();
        const QString* a1 = &a1def;
        int a1State = 0;

        static const char *sipKwdList[] = {
            sipName_cursorName,
            sipName_name,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|J1J1", sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlIndex(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            return sipCpp;
        }
    }

    {
        const QSqlIndex* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlIndex, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlIndex(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSqlIndex[] = {{20, 255, 1}};


static PyMethodDef methods_QSqlIndex[] = {
    {SIP_MLNAME_CAST(sipName_append), meth_QSqlIndex_append, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlIndex_append)},
    {SIP_MLNAME_CAST(sipName_cursorName), meth_QSqlIndex_cursorName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlIndex_cursorName)},
    {SIP_MLNAME_CAST(sipName_isDescending), meth_QSqlIndex_isDescending, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlIndex_isDescending)},
    {SIP_MLNAME_CAST(sipName_name), meth_QSqlIndex_name, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlIndex_name)},
    {SIP_MLNAME_CAST(sipName_setCursorName), meth_QSqlIndex_setCursorName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlIndex_setCursorName)},
    {SIP_MLNAME_CAST(sipName_setDescending), meth_QSqlIndex_setDescending, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlIndex_setDescending)},
    {SIP_MLNAME_CAST(sipName_setName), meth_QSqlIndex_setName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlIndex_setName)}
};

PyDoc_STRVAR(doc_QSqlIndex, "\1QSqlIndex(str cursorName='', str name='')\n"
    "QSqlIndex(QSqlIndex)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlIndex = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSqlIndex,
        {0}
    },
    {
        sipNameNr_QSqlIndex,
        {0, 0, 1},
        7, methods_QSqlIndex,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlIndex,
    -1,
    -1,
    supers_QSqlIndex,
    0,
    init_type_QSqlIndex,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlIndex,
    assign_QSqlIndex,
    array_QSqlIndex,
    copy_QSqlIndex,
    release_QSqlIndex,
    cast_QSqlIndex,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 16420 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 16424 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlfield.sip"
#include <qsqlfield.h>
#line 16427 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 16430 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


PyDoc_STRVAR(doc_QSqlRecord_value, "QSqlRecord.value(int) -> object\n"
    "QSqlRecord.value(str) -> object");

extern "C" {static PyObject *meth_QSqlRecord_value(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_value(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->value(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->value(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_value, doc_QSqlRecord_value);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_setValue, "QSqlRecord.setValue(int, object)\n"
    "QSqlRecord.setValue(str, object)");

extern "C" {static PyObject *meth_QSqlRecord_setValue(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_setValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QVariant* a1;
        int a1State = 0;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0, sipType_QVariant,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setValue(a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QVariant* a1;
        int a1State = 0;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State, sipType_QVariant,&a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setValue(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QVariant *>(a1),sipType_QVariant,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_setValue, doc_QSqlRecord_setValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_setNull, "QSqlRecord.setNull(int)\n"
    "QSqlRecord.setNull(str)");

extern "C" {static PyObject *meth_QSqlRecord_setNull(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_setNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNull(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNull(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_setNull, doc_QSqlRecord_setNull);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_isNull, "QSqlRecord.isNull(int) -> bool\n"
    "QSqlRecord.isNull(str) -> bool");

extern "C" {static PyObject *meth_QSqlRecord_isNull(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_isNull, doc_QSqlRecord_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_indexOf, "QSqlRecord.indexOf(str) -> int");

extern "C" {static PyObject *meth_QSqlRecord_indexOf(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_indexOf(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->indexOf(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_indexOf, doc_QSqlRecord_indexOf);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_fieldName, "QSqlRecord.fieldName(int) -> str");

extern "C" {static PyObject *meth_QSqlRecord_fieldName(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_fieldName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->fieldName(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_fieldName, doc_QSqlRecord_fieldName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_field, "QSqlRecord.field(int) -> QSqlField\n"
    "QSqlRecord.field(str) -> QSqlField");

extern "C" {static PyObject *meth_QSqlRecord_field(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_field(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0))
        {
            QSqlField*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlField(sipCpp->field(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlField,NULL);
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSqlField*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlField(sipCpp->field(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlField,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_field, doc_QSqlRecord_field);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_isGenerated, "QSqlRecord.isGenerated(int) -> bool\n"
    "QSqlRecord.isGenerated(str) -> bool");

extern "C" {static PyObject *meth_QSqlRecord_isGenerated(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_isGenerated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isGenerated(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isGenerated(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_isGenerated, doc_QSqlRecord_isGenerated);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_setGenerated, "QSqlRecord.setGenerated(str, bool)\n"
    "QSqlRecord.setGenerated(int, bool)");

extern "C" {static PyObject *meth_QSqlRecord_setGenerated(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_setGenerated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        bool a1;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1b", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setGenerated(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        bool a1;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bib", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setGenerated(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_setGenerated, doc_QSqlRecord_setGenerated);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_append, "QSqlRecord.append(QSqlField)");

extern "C" {static PyObject *meth_QSqlRecord_append(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_append(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField* a0;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QSqlField, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->append(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_append, doc_QSqlRecord_append);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_replace, "QSqlRecord.replace(int, QSqlField)");

extern "C" {static PyObject *meth_QSqlRecord_replace(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_replace(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlField* a1;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0, sipType_QSqlField, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->replace(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_replace, doc_QSqlRecord_replace);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_insert, "QSqlRecord.insert(int, QSqlField)");

extern "C" {static PyObject *meth_QSqlRecord_insert(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_insert(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const QSqlField* a1;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0, sipType_QSqlField, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->insert(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_insert, doc_QSqlRecord_insert);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_remove, "QSqlRecord.remove(int)");

extern "C" {static PyObject *meth_QSqlRecord_remove(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_remove(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlRecord, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->remove(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_remove, doc_QSqlRecord_remove);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_isEmpty, "QSqlRecord.isEmpty() -> bool");

extern "C" {static PyObject *meth_QSqlRecord_isEmpty(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_isEmpty(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRecord, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isEmpty();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_isEmpty, doc_QSqlRecord_isEmpty);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_contains, "QSqlRecord.contains(str) -> bool");

extern "C" {static PyObject *meth_QSqlRecord_contains(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_contains(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlRecord, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->contains(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_contains, doc_QSqlRecord_contains);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_clear, "QSqlRecord.clear()");

extern "C" {static PyObject *meth_QSqlRecord_clear(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_clear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRecord, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->clear();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_clear, doc_QSqlRecord_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_clearValues, "QSqlRecord.clearValues()");

extern "C" {static PyObject *meth_QSqlRecord_clearValues(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_clearValues(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRecord, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->clearValues();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_clearValues, doc_QSqlRecord_clearValues);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlRecord_count, "QSqlRecord.count() -> int");

extern "C" {static PyObject *meth_QSqlRecord_count(PyObject *, PyObject *);}
static PyObject *meth_QSqlRecord_count(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlRecord *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlRecord, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->count();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlRecord, sipName_count, doc_QSqlRecord_count);

    return NULL;
}


extern "C" {static SIP_SSIZE_T slot_QSqlRecord___len__(PyObject *);}
static SIP_SSIZE_T slot_QSqlRecord___len__(PyObject *sipSelf)
{
    QSqlRecord *sipCpp = reinterpret_cast<QSqlRecord *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSqlRecord));

    if (!sipCpp)
        return 0;


    {
        {
            SIP_SSIZE_T sipRes = 0;

#line 1 "Auto-generated"
            sipRes = (SIP_SSIZE_T)sipCpp->count();
#line 17119 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QSqlRecord___ne__(PyObject *,PyObject *);}
static PyObject *slot_QSqlRecord___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QSqlRecord *sipCpp = reinterpret_cast<QSqlRecord *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSqlRecord));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSqlRecord* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QSqlRecord, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QSqlRecord::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,ne_slot,sipType_QSqlRecord,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QSqlRecord___eq__(PyObject *,PyObject *);}
static PyObject *slot_QSqlRecord___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QSqlRecord *sipCpp = reinterpret_cast<QSqlRecord *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSqlRecord));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSqlRecord* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QSqlRecord, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QSqlRecord::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,eq_slot,sipType_QSqlRecord,sipSelf,sipArg);
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlRecord(void *, const sipTypeDef *);}
static void *cast_QSqlRecord(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlRecord)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlRecord(void *, int);}
static void release_QSqlRecord(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSqlRecord *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSqlRecord(void *, SIP_SSIZE_T, const void *);}
static void assign_QSqlRecord(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSqlRecord *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSqlRecord *>(sipSrc);
}


extern "C" {static void *array_QSqlRecord(SIP_SSIZE_T);}
static void *array_QSqlRecord(SIP_SSIZE_T sipNrElem)
{
    return new QSqlRecord[sipNrElem];
}


extern "C" {static void *copy_QSqlRecord(const void *, SIP_SSIZE_T);}
static void *copy_QSqlRecord(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSqlRecord(reinterpret_cast<const QSqlRecord *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSqlRecord(sipSimpleWrapper *);}
static void dealloc_QSqlRecord(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlRecord(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSqlRecord(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlRecord(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSqlRecord *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlRecord();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const QSqlRecord* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlRecord, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlRecord(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QSqlRecord[] = {
    {(void *)slot_QSqlRecord___len__, len_slot},
    {(void *)slot_QSqlRecord___ne__, ne_slot},
    {(void *)slot_QSqlRecord___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QSqlRecord[] = {
    {SIP_MLNAME_CAST(sipName_append), meth_QSqlRecord_append, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_append)},
    {SIP_MLNAME_CAST(sipName_clear), meth_QSqlRecord_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_clear)},
    {SIP_MLNAME_CAST(sipName_clearValues), meth_QSqlRecord_clearValues, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_clearValues)},
    {SIP_MLNAME_CAST(sipName_contains), meth_QSqlRecord_contains, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_contains)},
    {SIP_MLNAME_CAST(sipName_count), meth_QSqlRecord_count, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_count)},
    {SIP_MLNAME_CAST(sipName_field), meth_QSqlRecord_field, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_field)},
    {SIP_MLNAME_CAST(sipName_fieldName), meth_QSqlRecord_fieldName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_fieldName)},
    {SIP_MLNAME_CAST(sipName_indexOf), meth_QSqlRecord_indexOf, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_indexOf)},
    {SIP_MLNAME_CAST(sipName_insert), meth_QSqlRecord_insert, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_insert)},
    {SIP_MLNAME_CAST(sipName_isEmpty), meth_QSqlRecord_isEmpty, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_isEmpty)},
    {SIP_MLNAME_CAST(sipName_isGenerated), meth_QSqlRecord_isGenerated, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_isGenerated)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QSqlRecord_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_isNull)},
    {SIP_MLNAME_CAST(sipName_remove), meth_QSqlRecord_remove, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_remove)},
    {SIP_MLNAME_CAST(sipName_replace), meth_QSqlRecord_replace, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_replace)},
    {SIP_MLNAME_CAST(sipName_setGenerated), meth_QSqlRecord_setGenerated, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_setGenerated)},
    {SIP_MLNAME_CAST(sipName_setNull), meth_QSqlRecord_setNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_setNull)},
    {SIP_MLNAME_CAST(sipName_setValue), meth_QSqlRecord_setValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_setValue)},
    {SIP_MLNAME_CAST(sipName_value), meth_QSqlRecord_value, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlRecord_value)}
};

PyDoc_STRVAR(doc_QSqlRecord, "\1QSqlRecord()\n"
    "QSqlRecord(QSqlRecord)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlRecord = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSqlRecord,
        {0}
    },
    {
        sipNameNr_QSqlRecord,
        {0, 0, 1},
        18, methods_QSqlRecord,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlRecord,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QSqlRecord,
    init_type_QSqlRecord,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlRecord,
    assign_QSqlRecord,
    array_QSqlRecord,
    copy_QSqlRecord,
    release_QSqlRecord,
    cast_QSqlRecord,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlfield.sip"
#include <qsqlfield.h>
#line 17374 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 17378 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 17381 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


PyDoc_STRVAR(doc_QSqlField_setValue, "QSqlField.setValue(object)");

extern "C" {static PyObject *meth_QSqlField_setValue(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QVariant* a0;
        int a0State = 0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlField, &sipCpp, sipType_QVariant,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setValue(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setValue, doc_QSqlField_setValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_value, "QSqlField.value() -> object");

extern "C" {static PyObject *meth_QSqlField_value(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_value(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->value());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_value, doc_QSqlField_value);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setName, "QSqlField.setName(str)");

extern "C" {static PyObject *meth_QSqlField_setName(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlField, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setName, doc_QSqlField_setName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_name, "QSqlField.name() -> str");

extern "C" {static PyObject *meth_QSqlField_name(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_name(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->name());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_name, doc_QSqlField_name);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_isNull, "QSqlField.isNull() -> bool");

extern "C" {static PyObject *meth_QSqlField_isNull(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_isNull(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isNull();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_isNull, doc_QSqlField_isNull);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setReadOnly, "QSqlField.setReadOnly(bool)");

extern "C" {static PyObject *meth_QSqlField_setReadOnly(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setReadOnly(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QSqlField, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setReadOnly(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setReadOnly, doc_QSqlField_setReadOnly);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_isReadOnly, "QSqlField.isReadOnly() -> bool");

extern "C" {static PyObject *meth_QSqlField_isReadOnly(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_isReadOnly(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isReadOnly();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_isReadOnly, doc_QSqlField_isReadOnly);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_clear, "QSqlField.clear()");

extern "C" {static PyObject *meth_QSqlField_clear(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_clear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->clear();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_clear, doc_QSqlField_clear);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_type, "QSqlField.type() -> Type");

extern "C" {static PyObject *meth_QSqlField_type(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_type(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            QVariant::Type sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->type();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QVariant_Type);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_type, doc_QSqlField_type);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_isAutoValue, "QSqlField.isAutoValue() -> bool");

extern "C" {static PyObject *meth_QSqlField_isAutoValue(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_isAutoValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isAutoValue();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_isAutoValue, doc_QSqlField_isAutoValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setType, "QSqlField.setType(Type)");

extern "C" {static PyObject *meth_QSqlField_setType(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QVariant::Type a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlField, &sipCpp, sipType_QVariant_Type, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setType(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setType, doc_QSqlField_setType);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setRequiredStatus, "QSqlField.setRequiredStatus(QSqlField.RequiredStatus)");

extern "C" {static PyObject *meth_QSqlField_setRequiredStatus(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setRequiredStatus(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlField::RequiredStatus a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlField, &sipCpp, sipType_QSqlField_RequiredStatus, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setRequiredStatus(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setRequiredStatus, doc_QSqlField_setRequiredStatus);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setRequired, "QSqlField.setRequired(bool)");

extern "C" {static PyObject *meth_QSqlField_setRequired(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setRequired(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QSqlField, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setRequired(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setRequired, doc_QSqlField_setRequired);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setLength, "QSqlField.setLength(int)");

extern "C" {static PyObject *meth_QSqlField_setLength(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setLength(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlField, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setLength(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setLength, doc_QSqlField_setLength);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setPrecision, "QSqlField.setPrecision(int)");

extern "C" {static PyObject *meth_QSqlField_setPrecision(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setPrecision(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlField, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setPrecision(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setPrecision, doc_QSqlField_setPrecision);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setDefaultValue, "QSqlField.setDefaultValue(object)");

extern "C" {static PyObject *meth_QSqlField_setDefaultValue(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setDefaultValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QVariant* a0;
        int a0State = 0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlField, &sipCpp, sipType_QVariant,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDefaultValue(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QVariant *>(a0),sipType_QVariant,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setDefaultValue, doc_QSqlField_setDefaultValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setSqlType, "QSqlField.setSqlType(int)");

extern "C" {static PyObject *meth_QSqlField_setSqlType(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setSqlType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlField, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSqlType(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setSqlType, doc_QSqlField_setSqlType);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setGenerated, "QSqlField.setGenerated(bool)");

extern "C" {static PyObject *meth_QSqlField_setGenerated(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setGenerated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QSqlField, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setGenerated(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setGenerated, doc_QSqlField_setGenerated);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_setAutoValue, "QSqlField.setAutoValue(bool)");

extern "C" {static PyObject *meth_QSqlField_setAutoValue(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_setAutoValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QSqlField, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAutoValue(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_setAutoValue, doc_QSqlField_setAutoValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_requiredStatus, "QSqlField.requiredStatus() -> QSqlField.RequiredStatus");

extern "C" {static PyObject *meth_QSqlField_requiredStatus(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_requiredStatus(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            QSqlField::RequiredStatus sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->requiredStatus();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QSqlField_RequiredStatus);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_requiredStatus, doc_QSqlField_requiredStatus);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_length, "QSqlField.length() -> int");

extern "C" {static PyObject *meth_QSqlField_length(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_length(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->length();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_length, doc_QSqlField_length);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_precision, "QSqlField.precision() -> int");

extern "C" {static PyObject *meth_QSqlField_precision(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_precision(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->precision();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_precision, doc_QSqlField_precision);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_defaultValue, "QSqlField.defaultValue() -> object");

extern "C" {static PyObject *meth_QSqlField_defaultValue(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_defaultValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant(sipCpp->defaultValue());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_defaultValue, doc_QSqlField_defaultValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_typeID, "QSqlField.typeID() -> int");

extern "C" {static PyObject *meth_QSqlField_typeID(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_typeID(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->typeID();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_typeID, doc_QSqlField_typeID);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_isGenerated, "QSqlField.isGenerated() -> bool");

extern "C" {static PyObject *meth_QSqlField_isGenerated(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_isGenerated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isGenerated();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_isGenerated, doc_QSqlField_isGenerated);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlField_isValid, "QSqlField.isValid() -> bool");

extern "C" {static PyObject *meth_QSqlField_isValid(PyObject *, PyObject *);}
static PyObject *meth_QSqlField_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlField *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlField, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlField, sipName_isValid, doc_QSqlField_isValid);

    return NULL;
}


extern "C" {static PyObject *slot_QSqlField___ne__(PyObject *,PyObject *);}
static PyObject *slot_QSqlField___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QSqlField *sipCpp = reinterpret_cast<QSqlField *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSqlField));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSqlField* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QSqlField, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QSqlField::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,ne_slot,sipType_QSqlField,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QSqlField___eq__(PyObject *,PyObject *);}
static PyObject *slot_QSqlField___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QSqlField *sipCpp = reinterpret_cast<QSqlField *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSqlField));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSqlField* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QSqlField, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->QSqlField::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,eq_slot,sipType_QSqlField,sipSelf,sipArg);
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlField(void *, const sipTypeDef *);}
static void *cast_QSqlField(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlField)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlField(void *, int);}
static void release_QSqlField(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSqlField *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSqlField(void *, SIP_SSIZE_T, const void *);}
static void assign_QSqlField(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSqlField *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSqlField *>(sipSrc);
}


extern "C" {static void *array_QSqlField(SIP_SSIZE_T);}
static void *array_QSqlField(SIP_SSIZE_T sipNrElem)
{
    return new QSqlField[sipNrElem];
}


extern "C" {static void *copy_QSqlField(const void *, SIP_SSIZE_T);}
static void *copy_QSqlField(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSqlField(reinterpret_cast<const QSqlField *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSqlField(sipSimpleWrapper *);}
static void dealloc_QSqlField(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlField(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSqlField(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlField(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSqlField *sipCpp = 0;

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;
        QVariant::Type a1 = QVariant::Invalid;

        static const char *sipKwdList[] = {
            sipName_fieldName,
            sipName_type,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|J1E", sipType_QString,&a0, &a0State, sipType_QVariant_Type, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlField(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipCpp;
        }
    }

    {
        const QSqlField* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlField, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlField(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QSqlField[] = {
    {(void *)slot_QSqlField___ne__, ne_slot},
    {(void *)slot_QSqlField___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QSqlField[] = {
    {SIP_MLNAME_CAST(sipName_clear), meth_QSqlField_clear, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_clear)},
    {SIP_MLNAME_CAST(sipName_defaultValue), meth_QSqlField_defaultValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_defaultValue)},
    {SIP_MLNAME_CAST(sipName_isAutoValue), meth_QSqlField_isAutoValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_isAutoValue)},
    {SIP_MLNAME_CAST(sipName_isGenerated), meth_QSqlField_isGenerated, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_isGenerated)},
    {SIP_MLNAME_CAST(sipName_isNull), meth_QSqlField_isNull, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_isNull)},
    {SIP_MLNAME_CAST(sipName_isReadOnly), meth_QSqlField_isReadOnly, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_isReadOnly)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QSqlField_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_isValid)},
    {SIP_MLNAME_CAST(sipName_length), meth_QSqlField_length, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_length)},
    {SIP_MLNAME_CAST(sipName_name), meth_QSqlField_name, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_name)},
    {SIP_MLNAME_CAST(sipName_precision), meth_QSqlField_precision, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_precision)},
    {SIP_MLNAME_CAST(sipName_requiredStatus), meth_QSqlField_requiredStatus, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_requiredStatus)},
    {SIP_MLNAME_CAST(sipName_setAutoValue), meth_QSqlField_setAutoValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setAutoValue)},
    {SIP_MLNAME_CAST(sipName_setDefaultValue), meth_QSqlField_setDefaultValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setDefaultValue)},
    {SIP_MLNAME_CAST(sipName_setGenerated), meth_QSqlField_setGenerated, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setGenerated)},
    {SIP_MLNAME_CAST(sipName_setLength), meth_QSqlField_setLength, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setLength)},
    {SIP_MLNAME_CAST(sipName_setName), meth_QSqlField_setName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setName)},
    {SIP_MLNAME_CAST(sipName_setPrecision), meth_QSqlField_setPrecision, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setPrecision)},
    {SIP_MLNAME_CAST(sipName_setReadOnly), meth_QSqlField_setReadOnly, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setReadOnly)},
    {SIP_MLNAME_CAST(sipName_setRequired), meth_QSqlField_setRequired, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setRequired)},
    {SIP_MLNAME_CAST(sipName_setRequiredStatus), meth_QSqlField_setRequiredStatus, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setRequiredStatus)},
    {SIP_MLNAME_CAST(sipName_setSqlType), meth_QSqlField_setSqlType, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setSqlType)},
    {SIP_MLNAME_CAST(sipName_setType), meth_QSqlField_setType, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setType)},
    {SIP_MLNAME_CAST(sipName_setValue), meth_QSqlField_setValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_setValue)},
    {SIP_MLNAME_CAST(sipName_type), meth_QSqlField_type, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_type)},
    {SIP_MLNAME_CAST(sipName_typeID), meth_QSqlField_typeID, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_typeID)},
    {SIP_MLNAME_CAST(sipName_value), meth_QSqlField_value, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlField_value)}
};

static sipEnumMemberDef enummembers_QSqlField[] = {
    {sipName_Optional, static_cast<int>(QSqlField::Optional), 15},
    {sipName_Required, static_cast<int>(QSqlField::Required), 15},
    {sipName_Unknown, static_cast<int>(QSqlField::Unknown), 15},
};

PyDoc_STRVAR(doc_QSqlField, "\1QSqlField(str fieldName='', Type type=QVariant.Invalid)\n"
    "QSqlField(QSqlField)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlField = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSqlField,
        {0}
    },
    {
        sipNameNr_QSqlField,
        {0, 0, 1},
        26, methods_QSqlField,
        3, enummembers_QSqlField,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlField,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QSqlField,
    init_type_QSqlField,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlField,
    assign_QSqlField,
    array_QSqlField,
    copy_QSqlField,
    release_QSqlField,
    cast_QSqlField,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 18412 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 18416 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


PyDoc_STRVAR(doc_QSqlError_driverText, "QSqlError.driverText() -> str");

extern "C" {static PyObject *meth_QSqlError_driverText(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_driverText(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlError, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->driverText());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_driverText, doc_QSqlError_driverText);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_setDriverText, "QSqlError.setDriverText(str)");

extern "C" {static PyObject *meth_QSqlError_setDriverText(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_setDriverText(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlError, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDriverText(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_setDriverText, doc_QSqlError_setDriverText);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_databaseText, "QSqlError.databaseText() -> str");

extern "C" {static PyObject *meth_QSqlError_databaseText(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_databaseText(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlError, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->databaseText());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_databaseText, doc_QSqlError_databaseText);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_setDatabaseText, "QSqlError.setDatabaseText(str)");

extern "C" {static PyObject *meth_QSqlError_setDatabaseText(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_setDatabaseText(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlError, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDatabaseText(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_setDatabaseText, doc_QSqlError_setDatabaseText);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_type, "QSqlError.type() -> QSqlError.ErrorType");

extern "C" {static PyObject *meth_QSqlError_type(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_type(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlError, &sipCpp))
        {
            QSqlError::ErrorType sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->type();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QSqlError_ErrorType);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_type, doc_QSqlError_type);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_setType, "QSqlError.setType(QSqlError.ErrorType)");

extern "C" {static PyObject *meth_QSqlError_setType(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_setType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlError::ErrorType a0;
        QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlError, &sipCpp, sipType_QSqlError_ErrorType, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setType(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_setType, doc_QSqlError_setType);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_number, "QSqlError.number() -> int");

extern "C" {static PyObject *meth_QSqlError_number(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_number(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlError, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->number();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_number, doc_QSqlError_number);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_setNumber, "QSqlError.setNumber(int)");

extern "C" {static PyObject *meth_QSqlError_setNumber(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_setNumber(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlError, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNumber(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_setNumber, doc_QSqlError_setNumber);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_text, "QSqlError.text() -> str");

extern "C" {static PyObject *meth_QSqlError_text(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_text(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlError, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->text());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_text, doc_QSqlError_text);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlError_isValid, "QSqlError.isValid() -> bool");

extern "C" {static PyObject *meth_QSqlError_isValid(PyObject *, PyObject *);}
static PyObject *meth_QSqlError_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlError *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlError, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlError, sipName_isValid, doc_QSqlError_isValid);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlError(void *, const sipTypeDef *);}
static void *cast_QSqlError(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlError)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlError(void *, int);}
static void release_QSqlError(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSqlError *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSqlError(void *, SIP_SSIZE_T, const void *);}
static void assign_QSqlError(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSqlError *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSqlError *>(sipSrc);
}


extern "C" {static void *array_QSqlError(SIP_SSIZE_T);}
static void *array_QSqlError(SIP_SSIZE_T sipNrElem)
{
    return new QSqlError[sipNrElem];
}


extern "C" {static void *copy_QSqlError(const void *, SIP_SSIZE_T);}
static void *copy_QSqlError(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSqlError(reinterpret_cast<const QSqlError *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSqlError(sipSimpleWrapper *);}
static void dealloc_QSqlError(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlError(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSqlError(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlError(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSqlError *sipCpp = 0;

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;
        const QString& a1def = QString();
        const QString* a1 = &a1def;
        int a1State = 0;
        QSqlError::ErrorType a2 = QSqlError::NoError;
        int a3 = -1;

        static const char *sipKwdList[] = {
            sipName_driverText,
            sipName_databaseText,
            sipName_type,
            sipName_number,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|J1J1Ei", sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State, sipType_QSqlError_ErrorType, &a2, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlError(*a0,*a1,a2,a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            return sipCpp;
        }
    }

    {
        const QSqlError* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlError, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSqlError(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QSqlError[] = {
    {SIP_MLNAME_CAST(sipName_databaseText), meth_QSqlError_databaseText, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_databaseText)},
    {SIP_MLNAME_CAST(sipName_driverText), meth_QSqlError_driverText, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_driverText)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QSqlError_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_isValid)},
    {SIP_MLNAME_CAST(sipName_number), meth_QSqlError_number, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_number)},
    {SIP_MLNAME_CAST(sipName_setDatabaseText), meth_QSqlError_setDatabaseText, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_setDatabaseText)},
    {SIP_MLNAME_CAST(sipName_setDriverText), meth_QSqlError_setDriverText, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_setDriverText)},
    {SIP_MLNAME_CAST(sipName_setNumber), meth_QSqlError_setNumber, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_setNumber)},
    {SIP_MLNAME_CAST(sipName_setType), meth_QSqlError_setType, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_setType)},
    {SIP_MLNAME_CAST(sipName_text), meth_QSqlError_text, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_text)},
    {SIP_MLNAME_CAST(sipName_type), meth_QSqlError_type, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlError_type)}
};

static sipEnumMemberDef enummembers_QSqlError[] = {
    {sipName_ConnectionError, static_cast<int>(QSqlError::ConnectionError), 13},
    {sipName_NoError, static_cast<int>(QSqlError::NoError), 13},
    {sipName_StatementError, static_cast<int>(QSqlError::StatementError), 13},
    {sipName_TransactionError, static_cast<int>(QSqlError::TransactionError), 13},
    {sipName_UnknownError, static_cast<int>(QSqlError::UnknownError), 13},
};

PyDoc_STRVAR(doc_QSqlError, "\1QSqlError(str driverText='', str databaseText='', QSqlError.ErrorType type=QSqlError.NoError, int number=-1)\n"
    "QSqlError(QSqlError)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlError = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSqlError,
        {0}
    },
    {
        sipNameNr_QSqlError,
        {0, 0, 1},
        10, methods_QSqlError,
        5, enummembers_QSqlError,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlError,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QSqlError,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlError,
    assign_QSqlError,
    array_QSqlError,
    copy_QSqlError,
    release_QSqlError,
    cast_QSqlError,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldriver.sip"
#include <qsqldriver.h>
#line 18899 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 29 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 18903 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 18906 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 18909 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 18912 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 18915 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlresult.sip"
#include <qsqlresult.h>
#line 18918 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 269 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 18921 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 18924 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlfield.sip"
#include <qsqlfield.h>
#line 18927 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlindex.sip"
#include <qsqlindex.h>
#line 18930 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 18933 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 368 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 18936 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 351 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 18939 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 28 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 18942 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 32 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 18945 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 18948 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 115 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 18951 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 18954 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 18957 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 18960 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlDriver : public QSqlDriver
{
public:
    sipQSqlDriver(QObject*);
    virtual ~sipQSqlDriver();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool,QTimerEvent*);
    void sipProtectVirt_childEvent(bool,QChildEvent*);
    void sipProtectVirt_customEvent(bool,QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtectVirt_setOpen(bool,bool);
    void sipProtectVirt_setOpenError(bool,bool);
    void sipProtectVirt_setLastError(bool,const QSqlError&);
    bool sipProtect_subscribeToNotificationImplementation(const QString&);
    bool sipProtect_unsubscribeFromNotificationImplementation(const QString&);
    QStringList sipProtect_subscribedToNotificationsImplementation() const;
    bool sipProtect_isIdentifierEscapedImplementation(const QString&,QSqlDriver::IdentifierType) const;
    QString sipProtect_stripDelimitersImplementation(const QString&,QSqlDriver::IdentifierType) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent(QEvent*);
    void childEvent(QChildEvent*);
    void timerEvent(QTimerEvent*);
    bool eventFilter(QObject*,QEvent*);
    bool event(QEvent*);
    void setLastError(const QSqlError&);
    void setOpenError(bool);
    void setOpen(bool);
    bool open(const QString&,const QString&,const QString&,const QString&,int,const QString&);
    QSqlResult* createResult() const;
    void close();
    bool hasFeature(QSqlDriver::DriverFeature) const;
    QVariant handle() const;
    QString sqlStatement(QSqlDriver::StatementType,const QString&,const QSqlRecord&,bool) const;
    QString escapeIdentifier(const QString&,QSqlDriver::IdentifierType) const;
    QString formatValue(const QSqlField&,bool) const;
    QSqlRecord record(const QString&) const;
    QSqlIndex primaryIndex(const QString&) const;
    QStringList tables(QSql::TableType) const;
    bool rollbackTransaction();
    bool commitTransaction();
    bool beginTransaction();
    bool isOpen() const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlDriver(const sipQSqlDriver &);
    sipQSqlDriver &operator = (const sipQSqlDriver &);

    char sipPyMethods[25];
};

sipQSqlDriver::sipQSqlDriver(QObject*a0): QSqlDriver(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlDriver::~sipQSqlDriver()
{
    sipCommonDtor(sipPySelf);
}

const QMetaObject *sipQSqlDriver::metaObject() const
{
    return sip_QtSql_qt_metaobject(sipPySelf,sipType_QSqlDriver);
}

int sipQSqlDriver::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id = QSqlDriver::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtSql_qt_metacall(sipPySelf,sipType_QSqlDriver,_c,_id,_a);

    return _id;
}

void *sipQSqlDriver::qt_metacast(const char *_clname)
{
    return (sip_QtSql_qt_metacast(sipPySelf, sipType_QSqlDriver, _clname)) ? this : QSqlDriver::qt_metacast(_clname);
}

void sipQSqlDriver::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
        QSqlDriver::disconnectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlDriver::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
        QSqlDriver::connectNotify(a0);
        return;
    }

    typedef void (*sipVH_QtCore_24)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    ((sipVH_QtCore_24)(sipModuleAPI_QtSql_QtCore->em_virthandlers[24]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlDriver::customEvent(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
        QSqlDriver::customEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_17)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    ((sipVH_QtCore_17)(sipModuleAPI_QtSql_QtCore->em_virthandlers[17]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlDriver::childEvent(QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
        QSqlDriver::childEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_25)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QChildEvent*);

    ((sipVH_QtCore_25)(sipModuleAPI_QtSql_QtCore->em_virthandlers[25]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlDriver::timerEvent(QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
        QSqlDriver::timerEvent(a0);
        return;
    }

    typedef void (*sipVH_QtCore_9)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QTimerEvent*);

    ((sipVH_QtCore_9)(sipModuleAPI_QtSql_QtCore->em_virthandlers[9]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlDriver::eventFilter(QObject*a0,QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return QSqlDriver::eventFilter(a0,a1);

    typedef bool (*sipVH_QtCore_18)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QObject*,QEvent*);

    return ((sipVH_QtCore_18)(sipModuleAPI_QtSql_QtCore->em_virthandlers[18]))(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

bool sipQSqlDriver::event(QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return QSqlDriver::event(a0);

    typedef bool (*sipVH_QtCore_5)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QEvent*);

    return ((sipVH_QtCore_5)(sipModuleAPI_QtSql_QtCore->em_virthandlers[5]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlDriver::setLastError(const QSqlError& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_setLastError);

    if (!sipMeth)
    {
        QSqlDriver::setLastError(a0);
        return;
    }

    extern void sipVH_QtSql_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QSqlError&);

    sipVH_QtSql_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlDriver::setOpenError(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_setOpenError);

    if (!sipMeth)
    {
        QSqlDriver::setOpenError(a0);
        return;
    }

    typedef void (*sipVH_QtGui_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    ((sipVH_QtGui_6)(sipModuleAPI_QtSql_QtGui->em_virthandlers[6]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQSqlDriver::setOpen(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,NULL,sipName_setOpen);

    if (!sipMeth)
    {
        QSqlDriver::setOpen(a0);
        return;
    }

    typedef void (*sipVH_QtGui_6)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    ((sipVH_QtGui_6)(sipModuleAPI_QtSql_QtGui->em_virthandlers[6]))(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlDriver::open(const QString& a0,const QString& a1,const QString& a2,const QString& a3,int a4,const QString& a5)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,sipName_QSqlDriver,sipName_open);

    if (!sipMeth)
        return 0;

    extern bool sipVH_QtSql_10(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&,const QString&,const QString&,const QString&,int,const QString&);

    return sipVH_QtSql_10(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3, a4, a5);
}

QSqlResult* sipQSqlDriver::createResult() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[11]),sipPySelf,sipName_QSqlDriver,sipName_createResult);

    if (!sipMeth)
        return 0;

    extern QSqlResult* sipVH_QtSql_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSql_11(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQSqlDriver::close()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,sipName_QSqlDriver,sipName_close);

    if (!sipMeth)
        return;

    typedef void (*sipVH_QtCore_11)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    ((sipVH_QtCore_11)(sipModuleAPI_QtSql_QtCore->em_virthandlers[11]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlDriver::hasFeature(QSqlDriver::DriverFeature a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[13]),sipPySelf,sipName_QSqlDriver,sipName_hasFeature);

    if (!sipMeth)
        return 0;

    extern bool sipVH_QtSql_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QSqlDriver::DriverFeature);

    return sipVH_QtSql_12(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QVariant sipQSqlDriver::handle() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[14]),sipPySelf,NULL,sipName_handle);

    if (!sipMeth)
        return QSqlDriver::handle();

    extern QVariant sipVH_QtSql_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSql_3(sipGILState, 0, sipPySelf, sipMeth);
}

QString sipQSqlDriver::sqlStatement(QSqlDriver::StatementType a0,const QString& a1,const QSqlRecord& a2,bool a3) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[15]),sipPySelf,NULL,sipName_sqlStatement);

    if (!sipMeth)
        return QSqlDriver::sqlStatement(a0,a1,a2,a3);

    extern QString sipVH_QtSql_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QSqlDriver::StatementType,const QString&,const QSqlRecord&,bool);

    return sipVH_QtSql_13(sipGILState, 0, sipPySelf, sipMeth, a0, a1, a2, a3);
}

QString sipQSqlDriver::escapeIdentifier(const QString& a0,QSqlDriver::IdentifierType a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[16]),sipPySelf,NULL,sipName_escapeIdentifier);

    if (!sipMeth)
        return QSqlDriver::escapeIdentifier(a0,a1);

    extern QString sipVH_QtSql_14(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&,QSqlDriver::IdentifierType);

    return sipVH_QtSql_14(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QString sipQSqlDriver::formatValue(const QSqlField& a0,bool a1) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[17]),sipPySelf,NULL,sipName_formatValue);

    if (!sipMeth)
        return QSqlDriver::formatValue(a0,a1);

    extern QString sipVH_QtSql_15(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QSqlField&,bool);

    return sipVH_QtSql_15(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

QSqlRecord sipQSqlDriver::record(const QString& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[18]),sipPySelf,NULL,sipName_record);

    if (!sipMeth)
        return QSqlDriver::record(a0);

    extern QSqlRecord sipVH_QtSql_16(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    return sipVH_QtSql_16(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QSqlIndex sipQSqlDriver::primaryIndex(const QString& a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[19]),sipPySelf,NULL,sipName_primaryIndex);

    if (!sipMeth)
        return QSqlDriver::primaryIndex(a0);

    extern QSqlIndex sipVH_QtSql_17(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const QString&);

    return sipVH_QtSql_17(sipGILState, 0, sipPySelf, sipMeth, a0);
}

QStringList sipQSqlDriver::tables(QSql::TableType a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[20]),sipPySelf,NULL,sipName_tables);

    if (!sipMeth)
        return QSqlDriver::tables(a0);

    extern QStringList sipVH_QtSql_18(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, QSql::TableType);

    return sipVH_QtSql_18(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQSqlDriver::rollbackTransaction()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[21],sipPySelf,NULL,sipName_rollbackTransaction);

    if (!sipMeth)
        return QSqlDriver::rollbackTransaction();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlDriver::commitTransaction()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[22],sipPySelf,NULL,sipName_commitTransaction);

    if (!sipMeth)
        return QSqlDriver::commitTransaction();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlDriver::beginTransaction()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[23],sipPySelf,NULL,sipName_beginTransaction);

    if (!sipMeth)
        return QSqlDriver::beginTransaction();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQSqlDriver::isOpen() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[24]),sipPySelf,NULL,sipName_isOpen);

    if (!sipMeth)
        return QSqlDriver::isOpen();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI_QtSql_QtCore->em_virthandlers[7]))(sipGILState, 0, sipPySelf, sipMeth);
}

QObject* sipQSqlDriver::sipProtect_sender() const
{
    return QObject::sender();
}

int sipQSqlDriver::sipProtect_receivers(const char*a0) const
{
    return QObject::receivers(a0);
}

void sipQSqlDriver::sipProtectVirt_timerEvent(bool sipSelfWasArg,QTimerEvent*a0)
{
    (sipSelfWasArg ? QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQSqlDriver::sipProtectVirt_childEvent(bool sipSelfWasArg,QChildEvent*a0)
{
    (sipSelfWasArg ? QObject::childEvent(a0) : childEvent(a0));
}

void sipQSqlDriver::sipProtectVirt_customEvent(bool sipSelfWasArg,QEvent*a0)
{
    (sipSelfWasArg ? QObject::customEvent(a0) : customEvent(a0));
}

void sipQSqlDriver::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQSqlDriver::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ? QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQSqlDriver::sipProtect_senderSignalIndex() const
{
    return QObject::senderSignalIndex();
}

void sipQSqlDriver::sipProtectVirt_setOpen(bool sipSelfWasArg,bool a0)
{
    (sipSelfWasArg ? QSqlDriver::setOpen(a0) : setOpen(a0));
}

void sipQSqlDriver::sipProtectVirt_setOpenError(bool sipSelfWasArg,bool a0)
{
    (sipSelfWasArg ? QSqlDriver::setOpenError(a0) : setOpenError(a0));
}

void sipQSqlDriver::sipProtectVirt_setLastError(bool sipSelfWasArg,const QSqlError& a0)
{
    (sipSelfWasArg ? QSqlDriver::setLastError(a0) : setLastError(a0));
}

bool sipQSqlDriver::sipProtect_subscribeToNotificationImplementation(const QString& a0)
{
    return QSqlDriver::subscribeToNotificationImplementation(a0);
}

bool sipQSqlDriver::sipProtect_unsubscribeFromNotificationImplementation(const QString& a0)
{
    return QSqlDriver::unsubscribeFromNotificationImplementation(a0);
}

QStringList sipQSqlDriver::sipProtect_subscribedToNotificationsImplementation() const
{
    return QSqlDriver::subscribedToNotificationsImplementation();
}

bool sipQSqlDriver::sipProtect_isIdentifierEscapedImplementation(const QString& a0,QSqlDriver::IdentifierType a1) const
{
    return QSqlDriver::isIdentifierEscapedImplementation(a0,a1);
}

QString sipQSqlDriver::sipProtect_stripDelimitersImplementation(const QString& a0,QSqlDriver::IdentifierType a1) const
{
    return QSqlDriver::stripDelimitersImplementation(a0,a1);
}


PyDoc_STRVAR(doc_QSqlDriver_sender, "QSqlDriver.sender() -> QObject");

extern "C" {static PyObject *meth_QSqlDriver_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            QObject*sipRes = 0;

#line 638 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        if (helper)
            sipRes = helper(sipRes);
#line 19582 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_sender, doc_QSqlDriver_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_receivers, "QSqlDriver.receivers(SIGNAL()) -> int");

extern "C" {static PyObject *meth_QSqlDriver_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        char* a0;
        const sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlDriver, &sipCpp, &a0))
        {
            int sipRes = 0;

#line 664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helper if it hasn't already been done.
        typedef int (*helper_func)(QObject *, const char *, int);
        
        static helper_func helper = 0;
        
        if (!helper)
            helper = (helper_func)sipImportSymbol("qpycore_qobject_receivers");
        
        // PyQt5: Get rid of the const casts.
        if (helper)
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = helper(const_cast<QObject *>(sipCpp), a0, sipCpp->receivers(a0));
        #else
            sipRes = helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), a0, sipCpp->sipProtect_receivers(a0));
        #endif
#line 19627 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_receivers, doc_QSqlDriver_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_timerEvent, "QSqlDriver.timerEvent(QTimerEvent)");

extern "C" {static PyObject *meth_QSqlDriver_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QTimerEvent* a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_timerEvent, doc_QSqlDriver_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_childEvent, "QSqlDriver.childEvent(QChildEvent)");

extern "C" {static PyObject *meth_QSqlDriver_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QChildEvent* a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_childEvent, doc_QSqlDriver_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_customEvent, "QSqlDriver.customEvent(QEvent)");

extern "C" {static PyObject *meth_QSqlDriver_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QEvent* a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_customEvent, doc_QSqlDriver_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_connectNotify, "QSqlDriver.connectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlDriver_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlDriver, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_connectNotify, doc_QSqlDriver_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_disconnectNotify, "QSqlDriver.disconnectNotify(SIGNAL())");

extern "C" {static PyObject *meth_QSqlDriver_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        char* a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BG", &sipSelf, sipType_QSqlDriver, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_disconnectNotify, doc_QSqlDriver_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_senderSignalIndex, "QSqlDriver.senderSignalIndex() -> int");

extern "C" {static PyObject *meth_QSqlDriver_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_senderSignalIndex, doc_QSqlDriver_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_isOpen, "QSqlDriver.isOpen() -> bool");

extern "C" {static PyObject *meth_QSqlDriver_isOpen(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_isOpen(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlDriver::isOpen() : sipCpp->isOpen());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_isOpen, doc_QSqlDriver_isOpen);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_isOpenError, "QSqlDriver.isOpenError() -> bool");

extern "C" {static PyObject *meth_QSqlDriver_isOpenError(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_isOpenError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isOpenError();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_isOpenError, doc_QSqlDriver_isOpenError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_beginTransaction, "QSqlDriver.beginTransaction() -> bool");

extern "C" {static PyObject *meth_QSqlDriver_beginTransaction(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_beginTransaction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlDriver::beginTransaction() : sipCpp->beginTransaction());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_beginTransaction, doc_QSqlDriver_beginTransaction);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_commitTransaction, "QSqlDriver.commitTransaction() -> bool");

extern "C" {static PyObject *meth_QSqlDriver_commitTransaction(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_commitTransaction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlDriver::commitTransaction() : sipCpp->commitTransaction());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_commitTransaction, doc_QSqlDriver_commitTransaction);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_rollbackTransaction, "QSqlDriver.rollbackTransaction() -> bool");

extern "C" {static PyObject *meth_QSqlDriver_rollbackTransaction(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_rollbackTransaction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp->QSqlDriver::rollbackTransaction() : sipCpp->rollbackTransaction());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_rollbackTransaction, doc_QSqlDriver_rollbackTransaction);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_tables, "QSqlDriver.tables(QSql.TableType) -> list-of-str");

extern "C" {static PyObject *meth_QSqlDriver_tables(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_tables(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSql::TableType a0;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QSql_TableType, &a0))
        {
            QStringList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QStringList((sipSelfWasArg ? sipCpp->QSqlDriver::tables(a0) : sipCpp->tables(a0)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_tables, doc_QSqlDriver_tables);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_primaryIndex, "QSqlDriver.primaryIndex(str) -> QSqlIndex");

extern "C" {static PyObject *meth_QSqlDriver_primaryIndex(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_primaryIndex(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSqlIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlIndex((sipSelfWasArg ? sipCpp->QSqlDriver::primaryIndex(*a0) : sipCpp->primaryIndex(*a0)));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_primaryIndex, doc_QSqlDriver_primaryIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_record, "QSqlDriver.record(str) -> QSqlRecord");

extern "C" {static PyObject *meth_QSqlDriver_record(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_record(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSqlRecord*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlRecord((sipSelfWasArg ? sipCpp->QSqlDriver::record(*a0) : sipCpp->record(*a0)));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlRecord,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_record, doc_QSqlDriver_record);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_formatValue, "QSqlDriver.formatValue(QSqlField, bool trimStrings=False) -> str");

extern "C" {static PyObject *meth_QSqlDriver_formatValue(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_formatValue(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlField* a0;
        bool a1 = 0;
        const QSqlDriver *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_trimStrings,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|b", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QSqlField, &a0, &a1))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString((sipSelfWasArg ? sipCpp->QSqlDriver::formatValue(*a0,a1) : sipCpp->formatValue(*a0,a1)));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_formatValue, doc_QSqlDriver_formatValue);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_escapeIdentifier, "QSqlDriver.escapeIdentifier(str, QSqlDriver.IdentifierType) -> str");

extern "C" {static PyObject *meth_QSqlDriver_escapeIdentifier(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_escapeIdentifier(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriver::IdentifierType a1;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1E", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State, sipType_QSqlDriver_IdentifierType, &a1))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString((sipSelfWasArg ? sipCpp->QSqlDriver::escapeIdentifier(*a0,a1) : sipCpp->escapeIdentifier(*a0,a1)));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_escapeIdentifier, doc_QSqlDriver_escapeIdentifier);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_sqlStatement, "QSqlDriver.sqlStatement(QSqlDriver.StatementType, str, QSqlRecord, bool) -> str");

extern "C" {static PyObject *meth_QSqlDriver_sqlStatement(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_sqlStatement(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QSqlDriver::StatementType a0;
        const QString* a1;
        int a1State = 0;
        const QSqlRecord* a2;
        bool a3;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BEJ1J9b", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QSqlDriver_StatementType, &a0, sipType_QString,&a1, &a1State, sipType_QSqlRecord, &a2, &a3))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString((sipSelfWasArg ? sipCpp->QSqlDriver::sqlStatement(a0,*a1,*a2,a3) : sipCpp->sqlStatement(a0,*a1,*a2,a3)));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_sqlStatement, doc_QSqlDriver_sqlStatement);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_lastError, "QSqlDriver.lastError() -> QSqlError");

extern "C" {static PyObject *meth_QSqlDriver_lastError(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_lastError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            QSqlError*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlError(sipCpp->lastError());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlError,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_lastError, doc_QSqlDriver_lastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_handle, "QSqlDriver.handle() -> object");

extern "C" {static PyObject *meth_QSqlDriver_handle(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_handle(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            QVariant*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QVariant((sipSelfWasArg ? sipCpp->QSqlDriver::handle() : sipCpp->handle()));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QVariant,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_handle, doc_QSqlDriver_handle);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_hasFeature, "QSqlDriver.hasFeature(QSqlDriver.DriverFeature) -> bool");

extern "C" {static PyObject *meth_QSqlDriver_hasFeature(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_hasFeature(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QSqlDriver::DriverFeature a0;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QSqlDriver_DriverFeature, &a0))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlDriver, sipName_hasFeature);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->hasFeature(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_hasFeature, doc_QSqlDriver_hasFeature);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_close, "QSqlDriver.close()");

extern "C" {static PyObject *meth_QSqlDriver_close(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_close(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlDriver, sipName_close);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipCpp->close();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_close, doc_QSqlDriver_close);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_createResult, "QSqlDriver.createResult() -> QSqlResult");

extern "C" {static PyObject *meth_QSqlDriver_createResult(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_createResult(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            QSqlResult*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlDriver, sipName_createResult);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->createResult();
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlResult,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_createResult, doc_QSqlDriver_createResult);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_open, "QSqlDriver.open(str, str user='', str password='', str host='', int port=-1, str options='') -> bool");

extern "C" {static PyObject *meth_QSqlDriver_open(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_open(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QString* a0;
        int a0State = 0;
        const QString& a1def = QString();
        const QString* a1 = &a1def;
        int a1State = 0;
        const QString& a2def = QString();
        const QString* a2 = &a2def;
        int a2State = 0;
        const QString& a3def = QString();
        const QString* a3 = &a3def;
        int a3State = 0;
        int a4 = -1;
        const QString& a5def = QString();
        const QString* a5 = &a5def;
        int a5State = 0;
        QSqlDriver *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_user,
            sipName_password,
            sipName_host,
            sipName_port,
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1|J1J1J1iJ1", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State, sipType_QString,&a2, &a2State, sipType_QString,&a3, &a3State, &a4, sipType_QString,&a5, &a5State))
        {
            bool sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlDriver, sipName_open);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->open(*a0,*a1,*a2,*a3,a4,*a5);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);
            sipReleaseType(const_cast<QString *>(a2),sipType_QString,a2State);
            sipReleaseType(const_cast<QString *>(a3),sipType_QString,a3State);
            sipReleaseType(const_cast<QString *>(a5),sipType_QString,a5State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_open, doc_QSqlDriver_open);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_setOpen, "QSqlDriver.setOpen(bool)");

extern "C" {static PyObject *meth_QSqlDriver_setOpen(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_setOpen(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QSqlDriver, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setOpen(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_setOpen, doc_QSqlDriver_setOpen);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_setOpenError, "QSqlDriver.setOpenError(bool)");

extern "C" {static PyObject *meth_QSqlDriver_setOpenError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_setOpenError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QSqlDriver, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setOpenError(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_setOpenError, doc_QSqlDriver_setOpenError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_setLastError, "QSqlDriver.setLastError(QSqlError)");

extern "C" {static PyObject *meth_QSqlDriver_setLastError(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_setLastError(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        const QSqlError* a0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QSqlError, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_setLastError(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_setLastError, doc_QSqlDriver_setLastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_subscribeToNotification, "QSqlDriver.subscribeToNotification(str) -> bool");

extern "C" {static PyObject *meth_QSqlDriver_subscribeToNotification(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_subscribeToNotification(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->subscribeToNotification(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_subscribeToNotification, doc_QSqlDriver_subscribeToNotification);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_unsubscribeFromNotification, "QSqlDriver.unsubscribeFromNotification(str) -> bool");

extern "C" {static PyObject *meth_QSqlDriver_unsubscribeFromNotification(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_unsubscribeFromNotification(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->unsubscribeFromNotification(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_unsubscribeFromNotification, doc_QSqlDriver_unsubscribeFromNotification);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_subscribedToNotifications, "QSqlDriver.subscribedToNotifications() -> list-of-str");

extern "C" {static PyObject *meth_QSqlDriver_subscribedToNotifications(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_subscribedToNotifications(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            QStringList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QStringList(sipCpp->subscribedToNotifications());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_subscribedToNotifications, doc_QSqlDriver_subscribedToNotifications);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_subscribeToNotificationImplementation, "QSqlDriver.subscribeToNotificationImplementation(str) -> bool");

extern "C" {static PyObject *meth_QSqlDriver_subscribeToNotificationImplementation(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_subscribeToNotificationImplementation(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_subscribeToNotificationImplementation(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_subscribeToNotificationImplementation, doc_QSqlDriver_subscribeToNotificationImplementation);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_unsubscribeFromNotificationImplementation, "QSqlDriver.unsubscribeFromNotificationImplementation(str) -> bool");

extern "C" {static PyObject *meth_QSqlDriver_unsubscribeFromNotificationImplementation(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_unsubscribeFromNotificationImplementation(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_unsubscribeFromNotificationImplementation(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_unsubscribeFromNotificationImplementation, doc_QSqlDriver_unsubscribeFromNotificationImplementation);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_subscribedToNotificationsImplementation, "QSqlDriver.subscribedToNotificationsImplementation() -> list-of-str");

extern "C" {static PyObject *meth_QSqlDriver_subscribedToNotificationsImplementation(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_subscribedToNotificationsImplementation(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            QStringList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QStringList(sipCpp->sipProtect_subscribedToNotificationsImplementation());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_subscribedToNotificationsImplementation, doc_QSqlDriver_subscribedToNotificationsImplementation);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_isIdentifierEscapedImplementation, "QSqlDriver.isIdentifierEscapedImplementation(str, QSqlDriver.IdentifierType) -> bool");

extern "C" {static PyObject *meth_QSqlDriver_isIdentifierEscapedImplementation(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_isIdentifierEscapedImplementation(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriver::IdentifierType a1;
        const sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1E", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State, sipType_QSqlDriver_IdentifierType, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_isIdentifierEscapedImplementation(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_isIdentifierEscapedImplementation, doc_QSqlDriver_isIdentifierEscapedImplementation);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_stripDelimitersImplementation, "QSqlDriver.stripDelimitersImplementation(str, QSqlDriver.IdentifierType) -> str");

extern "C" {static PyObject *meth_QSqlDriver_stripDelimitersImplementation(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_stripDelimitersImplementation(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriver::IdentifierType a1;
        const sipQSqlDriver *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1E", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State, sipType_QSqlDriver_IdentifierType, &a1))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->sipProtect_stripDelimitersImplementation(*a0,a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_stripDelimitersImplementation, doc_QSqlDriver_stripDelimitersImplementation);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_isIdentifierEscaped, "QSqlDriver.isIdentifierEscaped(str, QSqlDriver.IdentifierType) -> bool");

extern "C" {static PyObject *meth_QSqlDriver_isIdentifierEscaped(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_isIdentifierEscaped(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriver::IdentifierType a1;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1E", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State, sipType_QSqlDriver_IdentifierType, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isIdentifierEscaped(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_isIdentifierEscaped, doc_QSqlDriver_isIdentifierEscaped);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_stripDelimiters, "QSqlDriver.stripDelimiters(str, QSqlDriver.IdentifierType) -> str");

extern "C" {static PyObject *meth_QSqlDriver_stripDelimiters(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_stripDelimiters(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriver::IdentifierType a1;
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1E", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QString,&a0, &a0State, sipType_QSqlDriver_IdentifierType, &a1))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->stripDelimiters(*a0,a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_stripDelimiters, doc_QSqlDriver_stripDelimiters);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_setNumericalPrecisionPolicy, "QSqlDriver.setNumericalPrecisionPolicy(QSql.NumericalPrecisionPolicy)");

extern "C" {static PyObject *meth_QSqlDriver_setNumericalPrecisionPolicy(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_setNumericalPrecisionPolicy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::NumericalPrecisionPolicy a0;
        QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlDriver, &sipCpp, sipType_QSql_NumericalPrecisionPolicy, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNumericalPrecisionPolicy(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_setNumericalPrecisionPolicy, doc_QSqlDriver_setNumericalPrecisionPolicy);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDriver_numericalPrecisionPolicy, "QSqlDriver.numericalPrecisionPolicy() -> QSql.NumericalPrecisionPolicy");

extern "C" {static PyObject *meth_QSqlDriver_numericalPrecisionPolicy(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriver_numericalPrecisionPolicy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDriver *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriver, &sipCpp))
        {
            QSql::NumericalPrecisionPolicy sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->numericalPrecisionPolicy();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QSql_NumericalPrecisionPolicy);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriver, sipName_numericalPrecisionPolicy, doc_QSqlDriver_numericalPrecisionPolicy);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlDriver(void *, const sipTypeDef *);}
static void *cast_QSqlDriver(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QSqlDriver)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QObject)->ctd_cast((QObject *)(QSqlDriver *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlDriver(void *, int);}
static void release_QSqlDriver(void *sipCppV,int)
{
    QSqlDriver *sipCpp = reinterpret_cast<QSqlDriver *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSqlDriver(sipSimpleWrapper *);}
static void dealloc_QSqlDriver(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlDriver *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlDriver(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlDriver(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlDriver(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQSqlDriver *sipCpp = 0;

    {
        QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlDriver(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QSqlDriver[] = {{141, 0, 1}};


static PyMethodDef methods_QSqlDriver[] = {
    {SIP_MLNAME_CAST(sipName_beginTransaction), meth_QSqlDriver_beginTransaction, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_beginTransaction)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QSqlDriver_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_close), meth_QSqlDriver_close, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_close)},
    {SIP_MLNAME_CAST(sipName_commitTransaction), meth_QSqlDriver_commitTransaction, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_commitTransaction)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QSqlDriver_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_createResult), meth_QSqlDriver_createResult, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_createResult)},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QSqlDriver_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QSqlDriver_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_escapeIdentifier), meth_QSqlDriver_escapeIdentifier, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_escapeIdentifier)},
    {SIP_MLNAME_CAST(sipName_formatValue), (PyCFunction)meth_QSqlDriver_formatValue, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_formatValue)},
    {SIP_MLNAME_CAST(sipName_handle), meth_QSqlDriver_handle, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_handle)},
    {SIP_MLNAME_CAST(sipName_hasFeature), meth_QSqlDriver_hasFeature, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_hasFeature)},
    {SIP_MLNAME_CAST(sipName_isIdentifierEscaped), meth_QSqlDriver_isIdentifierEscaped, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_isIdentifierEscaped)},
    {SIP_MLNAME_CAST(sipName_isIdentifierEscapedImplementation), (PyCFunction)meth_QSqlDriver_isIdentifierEscapedImplementation, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_isIdentifierEscapedImplementation)},
    {SIP_MLNAME_CAST(sipName_isOpen), meth_QSqlDriver_isOpen, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_isOpen)},
    {SIP_MLNAME_CAST(sipName_isOpenError), meth_QSqlDriver_isOpenError, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_isOpenError)},
    {SIP_MLNAME_CAST(sipName_lastError), meth_QSqlDriver_lastError, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_lastError)},
    {SIP_MLNAME_CAST(sipName_numericalPrecisionPolicy), meth_QSqlDriver_numericalPrecisionPolicy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_numericalPrecisionPolicy)},
    {SIP_MLNAME_CAST(sipName_open), (PyCFunction)meth_QSqlDriver_open, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_open)},
    {SIP_MLNAME_CAST(sipName_primaryIndex), meth_QSqlDriver_primaryIndex, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_primaryIndex)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QSqlDriver_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_record), meth_QSqlDriver_record, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_record)},
    {SIP_MLNAME_CAST(sipName_rollbackTransaction), meth_QSqlDriver_rollbackTransaction, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_rollbackTransaction)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QSqlDriver_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QSqlDriver_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setLastError), (PyCFunction)meth_QSqlDriver_setLastError, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_setLastError)},
    {SIP_MLNAME_CAST(sipName_setNumericalPrecisionPolicy), meth_QSqlDriver_setNumericalPrecisionPolicy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_setNumericalPrecisionPolicy)},
    {SIP_MLNAME_CAST(sipName_setOpen), (PyCFunction)meth_QSqlDriver_setOpen, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_setOpen)},
    {SIP_MLNAME_CAST(sipName_setOpenError), (PyCFunction)meth_QSqlDriver_setOpenError, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_setOpenError)},
    {SIP_MLNAME_CAST(sipName_sqlStatement), meth_QSqlDriver_sqlStatement, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_sqlStatement)},
    {SIP_MLNAME_CAST(sipName_stripDelimiters), meth_QSqlDriver_stripDelimiters, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_stripDelimiters)},
    {SIP_MLNAME_CAST(sipName_stripDelimitersImplementation), (PyCFunction)meth_QSqlDriver_stripDelimitersImplementation, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_stripDelimitersImplementation)},
    {SIP_MLNAME_CAST(sipName_subscribeToNotification), meth_QSqlDriver_subscribeToNotification, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_subscribeToNotification)},
    {SIP_MLNAME_CAST(sipName_subscribeToNotificationImplementation), (PyCFunction)meth_QSqlDriver_subscribeToNotificationImplementation, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_subscribeToNotificationImplementation)},
    {SIP_MLNAME_CAST(sipName_subscribedToNotifications), meth_QSqlDriver_subscribedToNotifications, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_subscribedToNotifications)},
    {SIP_MLNAME_CAST(sipName_subscribedToNotificationsImplementation), (PyCFunction)meth_QSqlDriver_subscribedToNotificationsImplementation, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_subscribedToNotificationsImplementation)},
    {SIP_MLNAME_CAST(sipName_tables), meth_QSqlDriver_tables, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_tables)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QSqlDriver_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_unsubscribeFromNotification), meth_QSqlDriver_unsubscribeFromNotification, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriver_unsubscribeFromNotification)},
    {SIP_MLNAME_CAST(sipName_unsubscribeFromNotificationImplementation), (PyCFunction)meth_QSqlDriver_unsubscribeFromNotificationImplementation, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDriver_unsubscribeFromNotificationImplementation)}
};

static sipEnumMemberDef enummembers_QSqlDriver[] = {
    {sipName_BLOB, static_cast<int>(QSqlDriver::BLOB), 8},
    {sipName_BatchOperations, static_cast<int>(QSqlDriver::BatchOperations), 8},
    {sipName_DeleteStatement, static_cast<int>(QSqlDriver::DeleteStatement), 10},
    {sipName_EventNotifications, static_cast<int>(QSqlDriver::EventNotifications), 8},
    {sipName_FieldName, static_cast<int>(QSqlDriver::FieldName), 9},
    {sipName_FinishQuery, static_cast<int>(QSqlDriver::FinishQuery), 8},
    {sipName_InsertStatement, static_cast<int>(QSqlDriver::InsertStatement), 10},
    {sipName_LastInsertId, static_cast<int>(QSqlDriver::LastInsertId), 8},
    {sipName_LowPrecisionNumbers, static_cast<int>(QSqlDriver::LowPrecisionNumbers), 8},
    {sipName_MultipleResultSets, static_cast<int>(QSqlDriver::MultipleResultSets), 8},
    {sipName_NamedPlaceholders, static_cast<int>(QSqlDriver::NamedPlaceholders), 8},
    {sipName_PositionalPlaceholders, static_cast<int>(QSqlDriver::PositionalPlaceholders), 8},
    {sipName_PreparedQueries, static_cast<int>(QSqlDriver::PreparedQueries), 8},
    {sipName_QuerySize, static_cast<int>(QSqlDriver::QuerySize), 8},
    {sipName_SelectStatement, static_cast<int>(QSqlDriver::SelectStatement), 10},
    {sipName_SimpleLocking, static_cast<int>(QSqlDriver::SimpleLocking), 8},
    {sipName_TableName, static_cast<int>(QSqlDriver::TableName), 9},
    {sipName_Transactions, static_cast<int>(QSqlDriver::Transactions), 8},
    {sipName_Unicode, static_cast<int>(QSqlDriver::Unicode), 8},
    {sipName_UpdateStatement, static_cast<int>(QSqlDriver::UpdateStatement), 10},
    {sipName_WhereStatement, static_cast<int>(QSqlDriver::WhereStatement), 10},
};


/* Define this type's signals. */
static const pyqt4QtSignal signals_QSqlDriver[] = {
    {"notification(QString)", "\1QSqlDriver.notification[str]", 0, 0},
    {0, 0, 0, 0}
};

PyDoc_STRVAR(doc_QSqlDriver, "\1QSqlDriver(QObject parent=None)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlDriver = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QSqlDriver,
        {0}
    },
    {
        sipNameNr_QSqlDriver,
        {0, 0, 1},
        40, methods_QSqlDriver,
        21, enummembers_QSqlDriver,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlDriver,
    -1,
    -1,
    supers_QSqlDriver,
    0,
    init_type_QSqlDriver,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlDriver,
    0,
    0,
    0,
    release_QSqlDriver,
    cast_QSqlDriver,
    0,
    0,
    0,
    0,
    0,
    0
},
    &QSqlDriver::staticMetaObject,
    0,
    signals_QSqlDriver,
};

#line 37 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 21081 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 21085 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldriver.sip"
#include <qsqldriver.h>
#line 21088 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 21091 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 21094 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 31 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qstringlist.sip"
#include <qstringlist.h>
#line 21097 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlerror.sip"
#include <qsqlerror.h>
#line 21100 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlquery.sip"
#include <qsqlquery.h>
#line 21103 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlrecord.sip"
#include <qsqlrecord.h>
#line 21106 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqlindex.sip"
#include <qsqlindex.h>
#line 21109 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlDatabase : public QSqlDatabase
{
public:
    sipQSqlDatabase();
    sipQSqlDatabase(const QSqlDatabase&);
    sipQSqlDatabase(const QString&);
    sipQSqlDatabase(QSqlDriver*);
    ~sipQSqlDatabase();

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlDatabase(const sipQSqlDatabase &);
    sipQSqlDatabase &operator = (const sipQSqlDatabase &);
};

sipQSqlDatabase::sipQSqlDatabase(): QSqlDatabase(), sipPySelf(0)
{
}

sipQSqlDatabase::sipQSqlDatabase(const QSqlDatabase& a0): QSqlDatabase(a0), sipPySelf(0)
{
}

sipQSqlDatabase::sipQSqlDatabase(const QString& a0): QSqlDatabase(a0), sipPySelf(0)
{
}

sipQSqlDatabase::sipQSqlDatabase(QSqlDriver*a0): QSqlDatabase(a0), sipPySelf(0)
{
}

sipQSqlDatabase::~sipQSqlDatabase()
{
    sipCommonDtor(sipPySelf);
}


PyDoc_STRVAR(doc_QSqlDatabase_open, "QSqlDatabase.open() -> bool\n"
    "QSqlDatabase.open(str, str) -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_open(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_open(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->open();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const QString* a0;
        int a0State = 0;
        const QString* a1;
        int a1State = 0;
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->open(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_open, doc_QSqlDatabase_open);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_close, "QSqlDatabase.close()");

extern "C" {static PyObject *meth_QSqlDatabase_close(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_close(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->close();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_close, doc_QSqlDatabase_close);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_isOpen, "QSqlDatabase.isOpen() -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_isOpen(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_isOpen(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isOpen();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_isOpen, doc_QSqlDatabase_isOpen);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_isOpenError, "QSqlDatabase.isOpenError() -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_isOpenError(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_isOpenError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isOpenError();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_isOpenError, doc_QSqlDatabase_isOpenError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_tables, "QSqlDatabase.tables(QSql.TableType type=QSql.Tables) -> list-of-str");

extern "C" {static PyObject *meth_QSqlDatabase_tables(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_tables(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::TableType a0 = QSql::Tables;
        const QSqlDatabase *sipCpp;

        static const char *sipKwdList[] = {
            sipName_type,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|E", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QSql_TableType, &a0))
        {
            QStringList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QStringList(sipCpp->tables(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_tables, doc_QSqlDatabase_tables);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_primaryIndex, "QSqlDatabase.primaryIndex(str) -> QSqlIndex");

extern "C" {static PyObject *meth_QSqlDatabase_primaryIndex(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_primaryIndex(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSqlIndex*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlIndex(sipCpp->primaryIndex(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlIndex,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_primaryIndex, doc_QSqlDatabase_primaryIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_record, "QSqlDatabase.record(str) -> QSqlRecord");

extern "C" {static PyObject *meth_QSqlDatabase_record(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_record(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSqlRecord*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlRecord(sipCpp->record(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlRecord,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_record, doc_QSqlDatabase_record);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_exec_, "QSqlDatabase.exec_(str query='') -> QSqlQuery");

extern "C" {static PyObject *meth_QSqlDatabase_exec_(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_exec_(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;
        const QSqlDatabase *sipCpp;

        static const char *sipKwdList[] = {
            sipName_query,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSqlQuery*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlQuery(sipCpp->exec(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlQuery,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_exec_, doc_QSqlDatabase_exec_);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_exec, "QSqlDatabase.exec(str query='') -> QSqlQuery");

extern "C" {static PyObject *meth_QSqlDatabase_exec(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_exec(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;
        const QSqlDatabase *sipCpp;

        static const char *sipKwdList[] = {
            sipName_query,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            QSqlQuery*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlQuery(sipCpp->exec(*a0));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlQuery,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_exec, doc_QSqlDatabase_exec);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_lastError, "QSqlDatabase.lastError() -> QSqlError");

extern "C" {static PyObject *meth_QSqlDatabase_lastError(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_lastError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QSqlError*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlError(sipCpp->lastError());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlError,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_lastError, doc_QSqlDatabase_lastError);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_isValid, "QSqlDatabase.isValid() -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_isValid(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_isValid, doc_QSqlDatabase_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_transaction, "QSqlDatabase.transaction() -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_transaction(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_transaction(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->transaction();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_transaction, doc_QSqlDatabase_transaction);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_commit, "QSqlDatabase.commit() -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_commit(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_commit(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->commit();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_commit, doc_QSqlDatabase_commit);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_rollback, "QSqlDatabase.rollback() -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_rollback(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_rollback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->rollback();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_rollback, doc_QSqlDatabase_rollback);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_setDatabaseName, "QSqlDatabase.setDatabaseName(str)");

extern "C" {static PyObject *meth_QSqlDatabase_setDatabaseName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_setDatabaseName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDatabaseName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_setDatabaseName, doc_QSqlDatabase_setDatabaseName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_setUserName, "QSqlDatabase.setUserName(str)");

extern "C" {static PyObject *meth_QSqlDatabase_setUserName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_setUserName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUserName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_setUserName, doc_QSqlDatabase_setUserName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_setPassword, "QSqlDatabase.setPassword(str)");

extern "C" {static PyObject *meth_QSqlDatabase_setPassword(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_setPassword(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setPassword(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_setPassword, doc_QSqlDatabase_setPassword);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_setHostName, "QSqlDatabase.setHostName(str)");

extern "C" {static PyObject *meth_QSqlDatabase_setHostName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_setHostName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setHostName(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_setHostName, doc_QSqlDatabase_setHostName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_setPort, "QSqlDatabase.setPort(int)");

extern "C" {static PyObject *meth_QSqlDatabase_setPort(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_setPort(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QSqlDatabase, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setPort(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_setPort, doc_QSqlDatabase_setPort);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_setConnectOptions, "QSqlDatabase.setConnectOptions(str options='')");

extern "C" {static PyObject *meth_QSqlDatabase_setConnectOptions(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_setConnectOptions(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString& a0def = QString();
        const QString* a0 = &a0def;
        int a0State = 0;
        QSqlDatabase *sipCpp;

        static const char *sipKwdList[] = {
            sipName_options,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J1", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setConnectOptions(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_setConnectOptions, doc_QSqlDatabase_setConnectOptions);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_databaseName, "QSqlDatabase.databaseName() -> str");

extern "C" {static PyObject *meth_QSqlDatabase_databaseName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_databaseName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->databaseName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_databaseName, doc_QSqlDatabase_databaseName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_userName, "QSqlDatabase.userName() -> str");

extern "C" {static PyObject *meth_QSqlDatabase_userName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_userName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->userName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_userName, doc_QSqlDatabase_userName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_password, "QSqlDatabase.password() -> str");

extern "C" {static PyObject *meth_QSqlDatabase_password(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_password(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->password());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_password, doc_QSqlDatabase_password);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_hostName, "QSqlDatabase.hostName() -> str");

extern "C" {static PyObject *meth_QSqlDatabase_hostName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_hostName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->hostName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_hostName, doc_QSqlDatabase_hostName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_driverName, "QSqlDatabase.driverName() -> str");

extern "C" {static PyObject *meth_QSqlDatabase_driverName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_driverName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->driverName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_driverName, doc_QSqlDatabase_driverName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_port, "QSqlDatabase.port() -> int");

extern "C" {static PyObject *meth_QSqlDatabase_port(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_port(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->port();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_port, doc_QSqlDatabase_port);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_connectOptions, "QSqlDatabase.connectOptions() -> str");

extern "C" {static PyObject *meth_QSqlDatabase_connectOptions(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_connectOptions(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->connectOptions());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_connectOptions, doc_QSqlDatabase_connectOptions);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_connectionName, "QSqlDatabase.connectionName() -> str");

extern "C" {static PyObject *meth_QSqlDatabase_connectionName(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_connectionName(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QString(sipCpp->connectionName());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_connectionName, doc_QSqlDatabase_connectionName);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_driver, "QSqlDatabase.driver() -> QSqlDriver");

extern "C" {static PyObject *meth_QSqlDatabase_driver(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_driver(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QSqlDriver*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->driver();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QSqlDriver,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_driver, doc_QSqlDatabase_driver);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_addDatabase, "QSqlDatabase.addDatabase(str, str connectionName=QLatin1String(QSqlDatabase.defaultConnection)) -> QSqlDatabase\n"
    "QSqlDatabase.addDatabase(QSqlDriver, str connectionName=QLatin1String(QSqlDatabase.defaultConnection)) -> QSqlDatabase");

extern "C" {static PyObject *meth_QSqlDatabase_addDatabase(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_addDatabase(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        const QString& a1def = QLatin1String(QSqlDatabase::defaultConnection);
        const QString* a1 = &a1def;
        int a1State = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_connectionName,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J1|J1", sipType_QString,&a0, &a0State, sipType_QString,&a1, &a1State))
        {
            QSqlDatabase*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlDatabase(QSqlDatabase::addDatabase(*a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QSqlDatabase,NULL);
        }
    }

    {
        QSqlDriver* a0;
        const QString& a1def = QLatin1String(QSqlDatabase::defaultConnection);
        const QString* a1 = &a1def;
        int a1State = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_connectionName,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8|J1", sipType_QSqlDriver, &a0, sipType_QString,&a1, &a1State))
        {
            QSqlDatabase*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlDatabase(QSqlDatabase::addDatabase(a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QSqlDatabase,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_addDatabase, doc_QSqlDatabase_addDatabase);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_cloneDatabase, "QSqlDatabase.cloneDatabase(QSqlDatabase, str) -> QSqlDatabase");

extern "C" {static PyObject *meth_QSqlDatabase_cloneDatabase(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_cloneDatabase(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase* a0;
        const QString* a1;
        int a1State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J9J1", sipType_QSqlDatabase, &a0, sipType_QString,&a1, &a1State))
        {
            QSqlDatabase*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlDatabase(QSqlDatabase::cloneDatabase(*a0,*a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a1),sipType_QString,a1State);

            return sipConvertFromNewType(sipRes,sipType_QSqlDatabase,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_cloneDatabase, doc_QSqlDatabase_cloneDatabase);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_database, "QSqlDatabase.database(str connectionName=QLatin1String(QSqlDatabase.defaultConnection), bool open=True) -> QSqlDatabase");

extern "C" {static PyObject *meth_QSqlDatabase_database(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_database(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString& a0def = QLatin1String(QSqlDatabase::defaultConnection);
        const QString* a0 = &a0def;
        int a0State = 0;
        bool a1 = 1;

        static const char *sipKwdList[] = {
            sipName_connectionName,
            sipName_open,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "|J1b", sipType_QString,&a0, &a0State, &a1))
        {
            QSqlDatabase*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSqlDatabase(QSqlDatabase::database(*a0,a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSqlDatabase,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_database, doc_QSqlDatabase_database);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_removeDatabase, "QSqlDatabase.removeDatabase(str)");

extern "C" {static PyObject *meth_QSqlDatabase_removeDatabase(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_removeDatabase(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1", sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            QSqlDatabase::removeDatabase(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_removeDatabase, doc_QSqlDatabase_removeDatabase);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_contains, "QSqlDatabase.contains(str connectionName=QLatin1String(QSqlDatabase.defaultConnection)) -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_contains(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_contains(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const QString& a0def = QLatin1String(QSqlDatabase::defaultConnection);
        const QString* a0 = &a0def;
        int a0State = 0;

        static const char *sipKwdList[] = {
            sipName_connectionName,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "|J1", sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = QSqlDatabase::contains(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_contains, doc_QSqlDatabase_contains);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_drivers, "QSqlDatabase.drivers() -> list-of-str");

extern "C" {static PyObject *meth_QSqlDatabase_drivers(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_drivers(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            QStringList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QStringList(QSqlDatabase::drivers());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_drivers, doc_QSqlDatabase_drivers);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_connectionNames, "QSqlDatabase.connectionNames() -> list-of-str");

extern "C" {static PyObject *meth_QSqlDatabase_connectionNames(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_connectionNames(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            QStringList*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QStringList(QSqlDatabase::connectionNames());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QStringList,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_connectionNames, doc_QSqlDatabase_connectionNames);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_registerSqlDriver, "QSqlDatabase.registerSqlDriver(str, QSqlDriverCreatorBase)");

extern "C" {static PyObject *meth_QSqlDatabase_registerSqlDriver(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_registerSqlDriver(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;
        QSqlDriverCreatorBase* a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1J:", sipType_QString,&a0, &a0State, sipType_QSqlDriverCreatorBase, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            QSqlDatabase::registerSqlDriver(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_registerSqlDriver, doc_QSqlDatabase_registerSqlDriver);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_isDriverAvailable, "QSqlDatabase.isDriverAvailable(str) -> bool");

extern "C" {static PyObject *meth_QSqlDatabase_isDriverAvailable(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_isDriverAvailable(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QString* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J1", sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = QSqlDatabase::isDriverAvailable(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_isDriverAvailable, doc_QSqlDatabase_isDriverAvailable);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_setNumericalPrecisionPolicy, "QSqlDatabase.setNumericalPrecisionPolicy(QSql.NumericalPrecisionPolicy)");

extern "C" {static PyObject *meth_QSqlDatabase_setNumericalPrecisionPolicy(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_setNumericalPrecisionPolicy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::NumericalPrecisionPolicy a0;
        QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QSqlDatabase, &sipCpp, sipType_QSql_NumericalPrecisionPolicy, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setNumericalPrecisionPolicy(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_setNumericalPrecisionPolicy, doc_QSqlDatabase_setNumericalPrecisionPolicy);

    return NULL;
}


PyDoc_STRVAR(doc_QSqlDatabase_numericalPrecisionPolicy, "QSqlDatabase.numericalPrecisionPolicy() -> QSql.NumericalPrecisionPolicy");

extern "C" {static PyObject *meth_QSqlDatabase_numericalPrecisionPolicy(PyObject *, PyObject *);}
static PyObject *meth_QSqlDatabase_numericalPrecisionPolicy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const QSqlDatabase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDatabase, &sipCpp))
        {
            QSql::NumericalPrecisionPolicy sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->numericalPrecisionPolicy();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(sipRes,sipType_QSql_NumericalPrecisionPolicy);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDatabase, sipName_numericalPrecisionPolicy, doc_QSqlDatabase_numericalPrecisionPolicy);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlDatabase(void *, const sipTypeDef *);}
static void *cast_QSqlDatabase(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlDatabase)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlDatabase(void *, int);}
static void release_QSqlDatabase(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQSqlDatabase *>(sipCppV);
    else
        delete reinterpret_cast<QSqlDatabase *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSqlDatabase(void *, SIP_SSIZE_T, const void *);}
static void assign_QSqlDatabase(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSqlDatabase *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSqlDatabase *>(sipSrc);
}


extern "C" {static void *array_QSqlDatabase(SIP_SSIZE_T);}
static void *array_QSqlDatabase(SIP_SSIZE_T sipNrElem)
{
    return new QSqlDatabase[sipNrElem];
}


extern "C" {static void *copy_QSqlDatabase(const void *, SIP_SSIZE_T);}
static void *copy_QSqlDatabase(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSqlDatabase(reinterpret_cast<const QSqlDatabase *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSqlDatabase(sipSimpleWrapper *);}
static void dealloc_QSqlDatabase(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlDatabase *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlDatabase(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlDatabase(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlDatabase(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQSqlDatabase *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlDatabase();
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const QSqlDatabase* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlDatabase, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlDatabase(*a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const QString* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QString,&a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlDatabase(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        QSqlDriver* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J8", sipType_QSqlDriver, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlDatabase(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QSqlDatabase[] = {
    {SIP_MLNAME_CAST(sipName_addDatabase), (PyCFunction)meth_QSqlDatabase_addDatabase, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDatabase_addDatabase)},
    {SIP_MLNAME_CAST(sipName_cloneDatabase), meth_QSqlDatabase_cloneDatabase, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_cloneDatabase)},
    {SIP_MLNAME_CAST(sipName_close), meth_QSqlDatabase_close, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_close)},
    {SIP_MLNAME_CAST(sipName_commit), meth_QSqlDatabase_commit, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_commit)},
    {SIP_MLNAME_CAST(sipName_connectOptions), meth_QSqlDatabase_connectOptions, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_connectOptions)},
    {SIP_MLNAME_CAST(sipName_connectionName), meth_QSqlDatabase_connectionName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_connectionName)},
    {SIP_MLNAME_CAST(sipName_connectionNames), meth_QSqlDatabase_connectionNames, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_connectionNames)},
    {SIP_MLNAME_CAST(sipName_contains), (PyCFunction)meth_QSqlDatabase_contains, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDatabase_contains)},
    {SIP_MLNAME_CAST(sipName_database), (PyCFunction)meth_QSqlDatabase_database, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDatabase_database)},
    {SIP_MLNAME_CAST(sipName_databaseName), meth_QSqlDatabase_databaseName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_databaseName)},
    {SIP_MLNAME_CAST(sipName_driver), meth_QSqlDatabase_driver, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_driver)},
    {SIP_MLNAME_CAST(sipName_driverName), meth_QSqlDatabase_driverName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_driverName)},
    {SIP_MLNAME_CAST(sipName_drivers), meth_QSqlDatabase_drivers, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_drivers)},
    {SIP_MLNAME_CAST(sipName_exec), (PyCFunction)meth_QSqlDatabase_exec, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDatabase_exec)},
    {SIP_MLNAME_CAST(sipName_exec_), (PyCFunction)meth_QSqlDatabase_exec_, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDatabase_exec_)},
    {SIP_MLNAME_CAST(sipName_hostName), meth_QSqlDatabase_hostName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_hostName)},
    {SIP_MLNAME_CAST(sipName_isDriverAvailable), meth_QSqlDatabase_isDriverAvailable, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_isDriverAvailable)},
    {SIP_MLNAME_CAST(sipName_isOpen), meth_QSqlDatabase_isOpen, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_isOpen)},
    {SIP_MLNAME_CAST(sipName_isOpenError), meth_QSqlDatabase_isOpenError, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_isOpenError)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QSqlDatabase_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_isValid)},
    {SIP_MLNAME_CAST(sipName_lastError), meth_QSqlDatabase_lastError, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_lastError)},
    {SIP_MLNAME_CAST(sipName_numericalPrecisionPolicy), meth_QSqlDatabase_numericalPrecisionPolicy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_numericalPrecisionPolicy)},
    {SIP_MLNAME_CAST(sipName_open), meth_QSqlDatabase_open, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_open)},
    {SIP_MLNAME_CAST(sipName_password), meth_QSqlDatabase_password, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_password)},
    {SIP_MLNAME_CAST(sipName_port), meth_QSqlDatabase_port, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_port)},
    {SIP_MLNAME_CAST(sipName_primaryIndex), meth_QSqlDatabase_primaryIndex, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_primaryIndex)},
    {SIP_MLNAME_CAST(sipName_record), meth_QSqlDatabase_record, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_record)},
    {SIP_MLNAME_CAST(sipName_registerSqlDriver), meth_QSqlDatabase_registerSqlDriver, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_registerSqlDriver)},
    {SIP_MLNAME_CAST(sipName_removeDatabase), meth_QSqlDatabase_removeDatabase, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_removeDatabase)},
    {SIP_MLNAME_CAST(sipName_rollback), meth_QSqlDatabase_rollback, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_rollback)},
    {SIP_MLNAME_CAST(sipName_setConnectOptions), (PyCFunction)meth_QSqlDatabase_setConnectOptions, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDatabase_setConnectOptions)},
    {SIP_MLNAME_CAST(sipName_setDatabaseName), meth_QSqlDatabase_setDatabaseName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_setDatabaseName)},
    {SIP_MLNAME_CAST(sipName_setHostName), meth_QSqlDatabase_setHostName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_setHostName)},
    {SIP_MLNAME_CAST(sipName_setNumericalPrecisionPolicy), meth_QSqlDatabase_setNumericalPrecisionPolicy, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_setNumericalPrecisionPolicy)},
    {SIP_MLNAME_CAST(sipName_setPassword), meth_QSqlDatabase_setPassword, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_setPassword)},
    {SIP_MLNAME_CAST(sipName_setPort), meth_QSqlDatabase_setPort, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_setPort)},
    {SIP_MLNAME_CAST(sipName_setUserName), meth_QSqlDatabase_setUserName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_setUserName)},
    {SIP_MLNAME_CAST(sipName_tables), (PyCFunction)meth_QSqlDatabase_tables, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QSqlDatabase_tables)},
    {SIP_MLNAME_CAST(sipName_transaction), meth_QSqlDatabase_transaction, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_transaction)},
    {SIP_MLNAME_CAST(sipName_userName), meth_QSqlDatabase_userName, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDatabase_userName)}
};

PyDoc_STRVAR(doc_QSqlDatabase, "\1QSqlDatabase()\n"
    "QSqlDatabase(QSqlDatabase)\n"
    "QSqlDatabase(str)\n"
    "QSqlDatabase(QSqlDriver)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlDatabase = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSqlDatabase,
        {0}
    },
    {
        sipNameNr_QSqlDatabase,
        {0, 0, 1},
        40, methods_QSqlDatabase,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlDatabase,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QSqlDatabase,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlDatabase,
    assign_QSqlDatabase,
    array_QSqlDatabase,
    copy_QSqlDatabase,
    release_QSqlDatabase,
    cast_QSqlDatabase,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldatabase.sip"
#include <qsqldatabase.h>
#line 22664 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 26 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsqldriver.sip"
#include <qsqldriver.h>
#line 22668 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


class sipQSqlDriverCreatorBase : public QSqlDriverCreatorBase
{
public:
    sipQSqlDriverCreatorBase();
    sipQSqlDriverCreatorBase(const QSqlDriverCreatorBase&);
    virtual ~sipQSqlDriverCreatorBase();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    QSqlDriver* createObject() const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQSqlDriverCreatorBase(const sipQSqlDriverCreatorBase &);
    sipQSqlDriverCreatorBase &operator = (const sipQSqlDriverCreatorBase &);

    char sipPyMethods[1];
};

sipQSqlDriverCreatorBase::sipQSqlDriverCreatorBase(): QSqlDriverCreatorBase(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlDriverCreatorBase::sipQSqlDriverCreatorBase(const QSqlDriverCreatorBase& a0): QSqlDriverCreatorBase(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQSqlDriverCreatorBase::~sipQSqlDriverCreatorBase()
{
    sipCommonDtor(sipPySelf);
}

QSqlDriver* sipQSqlDriverCreatorBase::createObject() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,sipName_QSqlDriverCreatorBase,sipName_createObject);

    if (!sipMeth)
        return 0;

    extern QSqlDriver* sipVH_QtSql_19(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtSql_19(sipGILState, 0, sipPySelf, sipMeth);
}


PyDoc_STRVAR(doc_QSqlDriverCreatorBase_createObject, "QSqlDriverCreatorBase.createObject() -> QSqlDriver");

extern "C" {static PyObject *meth_QSqlDriverCreatorBase_createObject(PyObject *, PyObject *);}
static PyObject *meth_QSqlDriverCreatorBase_createObject(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    PyObject *sipOrigSelf = sipSelf;

    {
        const QSqlDriverCreatorBase *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QSqlDriverCreatorBase, &sipCpp))
        {
            QSqlDriver*sipRes;

            if (!sipOrigSelf)
            {
                sipAbstractMethod(sipName_QSqlDriverCreatorBase, sipName_createObject);
                return NULL;
            }

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->createObject();
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSqlDriver,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QSqlDriverCreatorBase, sipName_createObject, doc_QSqlDriverCreatorBase_createObject);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSqlDriverCreatorBase(void *, const sipTypeDef *);}
static void *cast_QSqlDriverCreatorBase(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSqlDriverCreatorBase)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSqlDriverCreatorBase(void *, int);}
static void release_QSqlDriverCreatorBase(void *sipCppV,int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQSqlDriverCreatorBase *>(sipCppV);
    else
        delete reinterpret_cast<QSqlDriverCreatorBase *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QSqlDriverCreatorBase(sipSimpleWrapper *);}
static void dealloc_QSqlDriverCreatorBase(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQSqlDriverCreatorBase *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QSqlDriverCreatorBase(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QSqlDriverCreatorBase(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSqlDriverCreatorBase(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQSqlDriverCreatorBase *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlDriverCreatorBase();
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const QSqlDriverCreatorBase* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QSqlDriverCreatorBase, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQSqlDriverCreatorBase(*a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QSqlDriverCreatorBase[] = {
    {SIP_MLNAME_CAST(sipName_createObject), meth_QSqlDriverCreatorBase_createObject, METH_VARARGS, SIP_MLDOC_CAST(doc_QSqlDriverCreatorBase_createObject)}
};

PyDoc_STRVAR(doc_QSqlDriverCreatorBase, "\1QSqlDriverCreatorBase()\n"
    "QSqlDriverCreatorBase(QSqlDriverCreatorBase)");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSqlDriverCreatorBase = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_ABSTRACT|SIP_TYPE_CLASS,
        sipNameNr_QSqlDriverCreatorBase,
        {0}
    },
    {
        sipNameNr_QSqlDriverCreatorBase,
        {0, 0, 1},
        1, methods_QSqlDriverCreatorBase,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSqlDriverCreatorBase,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    -1,
    0,
    0,
    init_type_QSqlDriverCreatorBase,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSqlDriverCreatorBase,
    0,
    0,
    0,
    release_QSqlDriverCreatorBase,
    cast_QSqlDriverCreatorBase,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};

#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 22902 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 22906 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


extern "C" {static int slot_QSql_ParamType___bool__(PyObject *);}
static int slot_QSql_ParamType___bool__(PyObject *sipSelf)
{
    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 389 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QSql::ParamType::Int() != 0);
#else
        sipRes = (sipCpp->operator int() != 0);
#endif
#line 22928 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QSql_ParamType___ne__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___ne__(PyObject *sipSelf,PyObject *sipArg)
{
    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSql::ParamType* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QSql_ParamType, &a0, &a0State))
        {
            bool sipRes = 0;

#line 380 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QSql::ParamType::Int() != a0->operator QSql::ParamType::Int());
#else
        sipRes = (sipCpp->operator int() != a0->operator int());
#endif
#line 22962 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
            sipReleaseType(const_cast<QSql::ParamType *>(a0),sipType_QSql_ParamType,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,ne_slot,sipType_QSql_ParamType,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QSql_ParamType___eq__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___eq__(PyObject *sipSelf,PyObject *sipArg)
{
    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const QSql::ParamType* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QSql_ParamType, &a0, &a0State))
        {
            bool sipRes = 0;

#line 371 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QSql::ParamType::Int() == a0->operator QSql::ParamType::Int());
#else
        sipRes = (sipCpp->operator int() == a0->operator int());
#endif
#line 23002 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
            sipReleaseType(const_cast<QSql::ParamType *>(a0),sipType_QSql_ParamType,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,eq_slot,sipType_QSql_ParamType,sipSelf,sipArg);
}


extern "C" {static PyObject *slot_QSql_ParamType___invert__(PyObject *);}
static PyObject *slot_QSql_ParamType___invert__(PyObject *sipSelf)
{
    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return 0;


    {
        {
            QSql::ParamType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSql::ParamType(~(*sipCpp));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QSql_ParamType___and__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::ParamType* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSql_ParamType, &a0, &a0State, &a1))
        {
            QSql::ParamType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSql::ParamType((*a0 & a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QSql_ParamType,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,and_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QSql_ParamType___xor__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::ParamType* a0;
        int a0State = 0;
        QSql::ParamType* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1J1", sipType_QSql_ParamType, &a0, &a0State, sipType_QSql_ParamType, &a1, &a1State))
        {
            QSql::ParamType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSql::ParamType((*a0 ^ *a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QSql_ParamType,a0State);
            sipReleaseType(a1,sipType_QSql_ParamType,a1State);

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    {
        QSql::ParamType* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSql_ParamType, &a0, &a0State, &a1))
        {
            QSql::ParamType*sipRes = 0;

#line 365 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qglobal.sip"
        sipRes = new QSql::ParamType(*a0 ^ a1);
#line 23111 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
            sipReleaseType(a0,sipType_QSql_ParamType,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,xor_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QSql_ParamType___or__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
        QSql::ParamType* a0;
        int a0State = 0;
        QSql::ParamType* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1J1", sipType_QSql_ParamType, &a0, &a0State, sipType_QSql_ParamType, &a1, &a1State))
        {
            QSql::ParamType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QSql::ParamType((*a0 | *a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QSql_ParamType,a0State);
            sipReleaseType(a1,sipType_QSql_ParamType,a1State);

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    {
        QSql::ParamType* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QSql_ParamType, &a0, &a0State, &a1))
        {
            QSql::ParamType*sipRes = 0;

#line 360 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qglobal.sip"
        sipRes = new QSql::ParamType(*a0 | a1);
#line 23163 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
            sipReleaseType(a0,sipType_QSql_ParamType,a0State);

            return sipConvertFromNewType(sipRes,sipType_QSql_ParamType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtSql,or_slot,NULL,sipArg0,sipArg1);
}


extern "C" {static PyObject *slot_QSql_ParamType___int__(PyObject *);}
static PyObject *slot_QSql_ParamType___int__(PyObject *sipSelf)
{
    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = *sipCpp;
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QSql_ParamType___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QSql_ParamType)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        QSql::ParamType* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QSql_ParamType, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->QSql::ParamType::operator^=(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QSql_ParamType,a0State);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QSql_ParamType___ior__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QSql_ParamType)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        QSql::ParamType* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QSql_ParamType, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->QSql::ParamType::operator|=(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QSql_ParamType,a0State);

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QSql_ParamType___iand__(PyObject *,PyObject *);}
static PyObject *slot_QSql_ParamType___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QSql_ParamType)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    QSql::ParamType *sipCpp = reinterpret_cast<QSql::ParamType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QSql_ParamType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->QSql::ParamType::operator&=(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QSql_ParamType(void *, const sipTypeDef *);}
static void *cast_QSql_ParamType(void *ptr, const sipTypeDef *targetType)
{
    if (targetType == sipType_QSql_ParamType)
        return ptr;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QSql_ParamType(void *, int);}
static void release_QSql_ParamType(void *sipCppV,int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast<QSql::ParamType *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QSql_ParamType(void *, SIP_SSIZE_T, const void *);}
static void assign_QSql_ParamType(void *sipDst, SIP_SSIZE_T sipDstIdx, const void *sipSrc)
{
    reinterpret_cast<QSql::ParamType *>(sipDst)[sipDstIdx] = *reinterpret_cast<const QSql::ParamType *>(sipSrc);
}


extern "C" {static void *array_QSql_ParamType(SIP_SSIZE_T);}
static void *array_QSql_ParamType(SIP_SSIZE_T sipNrElem)
{
    return new QSql::ParamType[sipNrElem];
}


extern "C" {static void *copy_QSql_ParamType(const void *, SIP_SSIZE_T);}
static void *copy_QSql_ParamType(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QSql::ParamType(reinterpret_cast<const QSql::ParamType *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QSql_ParamType(sipSimpleWrapper *);}
static void dealloc_QSql_ParamType(sipSimpleWrapper *sipSelf)
{
    if (sipIsPyOwned(sipSelf))
    {
        release_QSql_ParamType(sipGetAddress(sipSelf),0);
    }
}


extern "C" {static void *init_type_QSql_ParamType(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QSql_ParamType(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    QSql::ParamType *sipCpp = 0;

    {
        const QSql::ParamType* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QSql_ParamType, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSql::ParamType(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast<QSql::ParamType *>(a0),sipType_QSql_ParamType,a0State);

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSql::ParamType(a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new QSql::ParamType();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QSql_ParamType(PyObject *, void **, int *, PyObject *);}
static int convertTo_QSql_ParamType(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QSql::ParamType **sipCppPtr = reinterpret_cast<QSql::ParamType **>(sipCppPtrV);

#line 398 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QSql::ParamType is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QSql_ParamTypeFlag)) ||
            sipCanConvertToType(sipPy, sipType_QSql_ParamType, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QSql_ParamTypeFlag)))
{
    *sipCppPtr = new QSql::ParamType(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QSql::ParamType *>(sipConvertToType(sipPy, sipType_QSql_ParamType, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 23458 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QSql_ParamType[] = {
    {(void *)slot_QSql_ParamType___bool__, bool_slot},
    {(void *)slot_QSql_ParamType___ne__, ne_slot},
    {(void *)slot_QSql_ParamType___eq__, eq_slot},
    {(void *)slot_QSql_ParamType___invert__, invert_slot},
    {(void *)slot_QSql_ParamType___and__, and_slot},
    {(void *)slot_QSql_ParamType___xor__, xor_slot},
    {(void *)slot_QSql_ParamType___or__, or_slot},
    {(void *)slot_QSql_ParamType___int__, int_slot},
    {(void *)slot_QSql_ParamType___ixor__, ixor_slot},
    {(void *)slot_QSql_ParamType___ior__, ior_slot},
    {(void *)slot_QSql_ParamType___iand__, iand_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QSql_ParamType, "\1QSql.ParamType(QSql.ParamType)\n"
    "QSql.ParamType(int)\n"
    "QSql.ParamType()");


pyqt4ClassTypeDef sipTypeDef_QtSql_QSql_ParamType = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QSql__ParamType,
        {0}
    },
    {
        sipNameNr_ParamType,
        {0, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QSql_ParamType,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QSql_ParamType,
    init_type_QSql_ParamType,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QSql_ParamType,
    assign_QSql_ParamType,
    array_QSql_ParamType,
    copy_QSql_ParamType,
    release_QSql_ParamType,
    cast_QSql_ParamType,
    convertTo_QSql_ParamType,
    0,
    0,
    0,
    0,
    0
},
    0,
    1,
    0
};

#line 30 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/sip/QtSql/qsql.sip"
#include <qsql.h>
#line 23539 "/usr/src/ports/python3-pyqt4/python3-pyqt4-4.11.4-1.x86_64/build/QtSql/sipQtSqlpart0.cpp"


static sipEnumMemberDef enummembers_QSql[] = {
    {sipName_AfterLastRow, static_cast<int>(QSql::AfterLastRow), 1},
    {sipName_AllTables, static_cast<int>(QSql::AllTables), 5},
    {sipName_BeforeFirstRow, static_cast<int>(QSql::BeforeFirstRow), 1},
    {sipName_Binary, static_cast<int>(QSql::Binary), 4},
    {sipName_HighPrecision, static_cast<int>(QSql::HighPrecision), 2},
    {sipName_In, static_cast<int>(QSql::In), 4},
    {sipName_InOut, static_cast<int>(QSql::InOut), 4},
    {sipName_LowPrecisionDouble, static_cast<int>(QSql::LowPrecisionDouble), 2},
    {sipName_LowPrecisionInt32, static_cast<int>(QSql::LowPrecisionInt32), 2},
    {sipName_LowPrecisionInt64, static_cast<int>(QSql::LowPrecisionInt64), 2},
    {sipName_Out, static_cast<int>(QSql::Out), 4},
    {sipName_SystemTables, static_cast<int>(QSql::SystemTables), 5},
    {sipName_Tables, static_cast<int>(QSql::Tables), 5},
    {sipName_Views, static_cast<int>(QSql::Views), 5},
};


pyqt4ClassTypeDef sipTypeDef_QtSql_QSql = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_NAMESPACE,
        sipNameNr_QSql,
        {0}
    },
    {
        sipNameNr_QSql,
        {0, 0, 1},
        0, 0,
        14, enummembers_QSql,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0
};
