Merge pull request #262 from mappu/readme-updates-20250904

doc/README: Qt SQL is implemented, macOS ARM64 works, add code_edit link

.gitignore

@@ -31,6 +31,7 @@ examples/libraries/qt-network/qt-network
 examples/libraries/qt-pdf/qt-pdf
 examples/libraries/qt-printsupport/qt-printsupport
 examples/libraries/qt-script/qt-script
+examples/libraries/qt-sql/qt-sql
 examples/libraries/qt-svg/qt-svg
 examples/libraries/qt-webengine/qt-webengine
 examples/libraries/qt-webkit/qt-webkit

CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 2025-08-09 v0.11.2
+
+- Fix the libmiqt package going missing when using go mod vendor (#252, #254)
+- Fix pkg-config file names for building Qt5 statically on Windows (#253, #254)
+
 ## 2025-08-04 v0.11.1
 
 - Automatically detect podman in `miqt-docker` without requiring `DOCKER=podman` (#247 by @dezza)

README.md

@@ -12,7 +12,7 @@ MIQT is MIT-licensed Qt bindings for Go.
 
 This is a straightforward binding of the Qt 5.15 / Qt 6.4+ API using CGO. You must have a working Qt C++ development toolchain to use this Go binding.
 
-These bindings were newly started in August 2024. The bindings are complete for QtCore, QtGui, QtWidgets, QtMultimedia, QtMultimediaWidgets, QtSpatialAudio, QtPrintSupport, QtSvg, QtScript, QtNetwork, QtWebkit, QtWebChannel, QtWebEngine, QtCharts, QML, QScintilla, ScintillaEdit, there is subclassing support, and there is a uic/rcc implementation. But, the bindings may be immature in some ways. Please try out the bindings and raise issues if you have trouble.
+These bindings were newly started in August 2024. The bindings are complete for QtCore, QtGui, QtWidgets, Qt SQL, QtMultimedia, QtMultimediaWidgets, QtSpatialAudio, QtPrintSupport, QtSvg, QtScript, QtNetwork, QtWebkit, QtWebChannel, QtWebEngine, QtCharts, QML, QScintilla, ScintillaEdit, there is subclassing support, and there is a uic/rcc implementation. But, the bindings may be immature in some ways. Please try out the bindings and raise issues if you have trouble.
 
 ## Supported platforms
 
@@ -24,7 +24,7 @@ These bindings were newly started in August 2024. The bindings are complete for
 |Android|ARM64|Dynamic (bundled in .apk package)|✅ Works
 |FreeBSD|x86_64|Static or Dynamic (.so)|✅ Works
 |macOS|x86_64|Static or Dynamic (.dylib)|✅ Works
-|macOS|ARM64|Static or Dynamic (.dylib)|Should work, not tested
+|macOS|ARM64|Static or Dynamic (.dylib)|✅ Works
 
 ## License
 
@@ -37,6 +37,7 @@ You must also meet your Qt license obligations.
 These apps are listed in alphabetical order. Raise an issue or PR to have your app listed here!
 
 - [annie-miqt](https://code.ivysaur.me/annie-miqt), a GUI application for downloading videos.
+- [code_edit](https://github.com/mappu/miqt/discussions/259), a QSyntaxHighlighter for Go source code
 - [jqview](https://github.com/rcalixte/jqview), The simplest possible native GUI for inspecting JSON objects with jq
 - [libqt6zig](https://github.com/rcalixte/libqt6zig), Qt bindings for Zig and C based on MIQT
 - [mdoutliner](https://github.com/mappu/miqt/tree/master/examples/mdoutliner), Markdown Outliner sample application
@@ -338,6 +339,8 @@ go build -ldflags '-s -w'
 
 Installing `qt@5` from Homebrew may be very slow if Homebrew chooses to do a from-source build instead of a binary Bottle build, particularly owing to QtWebEngine (Chromium).
 
+> If you get an error related to `pkg-config` when building the miqt application after installing the `pkg-config` tool with **brew**, you may have forgotten to add environment variables. To do this, do not forget to apply the instructions in the output of `brew install PKG-config` command. You can find related discussion about this topic by clicking this link -> https://github.com/mappu/miqt/discussions/257.
+
 ### macOS (Docker)
 
 *Tested with osxcross 14.5 / Go 1.19 / MacPorts Qt 5.15 / Debian Clang 14.0*

cmd/genbindings/clang2il.go

@@ -8,172 +8,125 @@ import (
 	"strings"
 )
 
+type HeaderMatcher func(astNodeFilename, curFilename string) bool
+
+func ClangMatchSameHeaderDefinitionOnly(astNodeFilename, curFilename string) bool {
+	return astNodeFilename == curFilename
+}
+
+type clangMatchUnderPath struct {
+	basePath string
+}
+
+func (c *clangMatchUnderPath) Match(astNodeFilename, curFilename string) bool {
+	if astNodeFilename == curFilename {
+		return true
+	}
+	return strings.HasPrefix(astNodeFilename, c.basePath)
+}
+
 var (
 	ErrTooComplex = errors.New("Type declaration is too complex to parse")
 	ErrNoContent  = errors.New("There's no content to include")
 )
 
+func (node *AstNode) file() string {
+	if loc, ok := node.Fields["loc"].(map[string]interface{}); ok {
+		if file, ok := loc["file"].(string); ok {
+			return file
+		}
+		if expansion, ok := loc["expansionLoc"].(map[string]interface{}); ok {
+			if file, ok := expansion["file"].(string); ok {
+				return file
+			}
+		}
+	}
+	return ""
+}
+
 // parseHeader parses a whole C++ header into our CppParsedHeader intermediate format.
-func parseHeader(topLevel []interface{}, addNamePrefix string) (*CppParsedHeader, error) {
-
-	var ret CppParsedHeader
-
-nextTopLevel:
-	for _, node := range topLevel {
-
-		node, ok := node.(map[string]interface{})
-		if !ok {
-			return nil, errors.New("inner[] element not an object")
-		}
-
-		kind, ok := node["kind"].(string)
-		if !ok {
-			return nil, errors.New("node has no kind")
-		}
-
+func parseHeader(node *AstNode, addNamePrefix string, output *CppParsedHeader, matcher HeaderMatcher) {
+	kind := node.Kind
 	switch kind {
+	case "TranslationUnitDecl":
+		for _, inner := range node.Inner {
+			parseHeader(inner, addNamePrefix, output, matcher)
+		}
+	case "NamespaceDecl":
+		if !matcher(node.file(), output.Filename) {
+			return
+		}
+
+		// Parse everything inside the namespace with prefix, as if it is
+		// a whole separate file
+		// Then copy the parsed elements back into our own file
+		namespace, ok := node.Fields["name"].(string)
+		if ok {
+			// Only process named namespaces
+			namespaceInner := node.Inner
+			for _, inner := range namespaceInner {
+				parseHeader(inner, addNamePrefix+namespace+"::", output, matcher)
+			}
+		}
 
 	case "CXXRecordDecl":
+		if !matcher(node.file(), output.Filename) {
+			return
+		}
 
 		// Process the inner class definition
 		obj, err := processClassType(node, addNamePrefix)
 		if err != nil {
 			if errors.Is(err, ErrNoContent) {
 				log.Printf("-> Skipping (%v)\n", err)
-					continue
+				return
 			}
 
 			// A real error (shouldn't happen)
 			panic(err)
 		}
 
-			ret.Classes = append(ret.Classes, obj)
-
-		case "StaticAssertDecl":
-			// ignore
-
-		case "ClassTemplateDecl",
-			"ClassTemplateSpecializationDecl",
-			"ClassTemplatePartialSpecializationDecl",
-			"FunctionTemplateDecl",
-			"BuiltinTemplateDecl",                  // Scintilla
-			"VarTemplatePartialSpecializationDecl", // e.g. Qt6 qcontainerinfo.h
-			"VarTemplateSpecializationDecl",        // e.g. qhashfunctions.h
-			"TypeAliasTemplateDecl",                // e.g. qendian.h
-			"VarTemplateDecl":                      // e.g. qglobal.h
-			// Template stuff probably can't be supported in the binding since
-			// we would need to link a concrete instantiation for each type in
-			// the CABI
-			// Ignore this node
-
-		case "FileScopeAsmDecl":
-			// ignore
-
-		case "NamespaceDecl":
-			// Parse everything inside the namespace with prefix, as if it is
-			// a whole separate file
-			// Then copy the parsed elements back into our own file
-			namespace, ok := node["name"].(string)
-			if !ok {
-				// Qt 5 has none of these
-				// Qt 6 has some e.g. qloggingcategory.h
-				// Treat it as not having existed
-				continue nextTopLevel
-			}
-
-			namespaceInner, ok := node["inner"].([]interface{})
-			if !ok {
-				// A namespace declaration with no inner content means that, for
-				// the rest of this whole file, we are in this namespace
-				// Update our own `addNamePrefix` accordingly
-				addNamePrefix += namespace + "::"
-
-			} else {
-
-				contents, err := parseHeader(namespaceInner, addNamePrefix+namespace+"::")
-				if err != nil {
-					panic(err)
-				}
-
-				ret.AddContentFrom(contents)
-			}
-
-		case "FunctionDecl":
-			// TODO
+		output.Classes = append(output.Classes, obj)
 
 	case "EnumDecl":
+		if !matcher(node.file(), output.Filename) {
+			return
+		}
 		// Child class enum
 		en, err := processEnum(node, addNamePrefix)
 		if err != nil {
 			panic(fmt.Errorf("processEnum: %w", err)) // A real problem
 		}
-
 		// n.b. In some cases we may produce multiple "copies" of an enum
 		// (e.g. qcborcommon and qmetatype both define QCborSimpleType)
 		// Allow, but use a transform pass to avoid multiple definitions of
 		// it
-			ret.Enums = append(ret.Enums, en)
-
-		case "VarDecl":
-			// TODO e.g. qmath.h
-			// We could probably generate setter/getter for this in the CABI
-
-		case "CXXConstructorDecl":
-			// TODO (why is this at the top level? e.g qobject.h)
-
-		case "CXXDestructorDecl":
-			// ignore
-
-		case "CXXConversionDecl":
-			// TODO (e.g. qbytearray.h)
-
-		case "LinkageSpecDecl":
-			// TODO e.g. qfuturewatcher.h
-			// Probably can't be supported in the Go binding
-
-		case "AbiTagAttr":
-			// e.g. scintilla.org ScintillaEditBase
-		case "VisibilityAttr":
-			// e.g. scintilla.org ScintillaEditBase
-			// Don't understand why this appears at top level??
-
-		case "UsingDirectiveDecl", // qtextstream.h
-			"UsingDecl",       // qglobal.h
-			"UsingShadowDecl": // global.h
-			// TODO e.g.
-			// Should be treated like a typedef
+		output.Enums = append(output.Enums, en)
 
 	case "TypeAliasDecl", "TypedefDecl":
+		if !matcher(node.file(), output.Filename) {
+			return
+		}
+
 		td, err := processTypedef(node, addNamePrefix)
 		if err != nil {
-				return nil, fmt.Errorf("processTypedef: %w", err)
+			panic(fmt.Errorf("processTypedef: %w", err)) // A real problem
 		}
-			ret.Typedefs = append(ret.Typedefs, td)
-
-		case "CXXMethodDecl":
-			// A C++ class method implementation directly in the header
-			// Skip over these
-
-		case "FullComment":
-			// Safe to skip
-
+		output.Typedefs = append(output.Typedefs, td)
 	default:
-			return nil, fmt.Errorf("missing handling for clang ast node type %q", kind)
+		panic(fmt.Sprintf("missing handling for clang ast node type %q id %v", kind, node.Id))
 	}
 }
 
-	return &ret, nil // done
-}
-
 // processTypedef parses a single C++ typedef into our intermediate format.
-func processTypedef(node map[string]interface{}, addNamePrefix string) (CppTypedef, error) {
+func processTypedef(node *AstNode, addNamePrefix string) (CppTypedef, error) {
 	// Must have a name
-	nodename, ok := node["name"].(string)
+	nodename, ok := node.Fields["name"].(string)
 	if !ok {
 		return CppTypedef{}, errors.New("node has no name")
 	}
 
-	if typ, ok := node["type"].(map[string]interface{}); ok {
+	if typ, ok := node.Fields["type"].(map[string]interface{}); ok {
 		if qualType, ok := typ["qualType"].(string); ok {
 			return CppTypedef{
 				Alias:          addNamePrefix + nodename,
@@ -194,12 +147,12 @@ const (
 )
 
 // processClassType parses a single C++ class definition into our intermediate format.
-func processClassType(node map[string]interface{}, addNamePrefix string) (CppClass, error) {
+func processClassType(node *AstNode, addNamePrefix string) (CppClass, error) {
 	var ret CppClass
 	ret.CanDelete = true
 
 	// Must have a name
-	nodename, ok := node["name"].(string)
+	nodename, ok := node.Fields["name"].(string)
 	if !ok {
 		// This can happen for some nested class definitions e.g. qbytearraymatcher.h::Data
 		return CppClass{}, ErrNoContent // errors.New("node has no name")
@@ -223,15 +176,14 @@ func processClassType(node map[string]interface{}, addNamePrefix string) (CppCla
 	// Skip over forward class declarations
 	// This is determined in two ways:
 	// 1. If the class has no inner nodes
-	inner, ok := node["inner"].([]interface{})
-	if !ok {
+	if len(node.Inner) == 0 {
 		return CppClass{}, ErrNoContent
 	}
 
 	// 2. If this class has only one `inner` entry that's a VisibilityAttr
-	if len(inner) == 1 {
-		if node, ok := inner[0].(map[string]interface{}); ok {
-			if kind, ok := node["kind"].(string); ok && kind == "VisibilityAttr" {
+	if len(node.Inner) == 1 {
+		if node := node.Inner[0]; ok {
+			if node.Kind == "VisibilityAttr" {
 				return CppClass{}, ErrNoContent
 			}
 		}
@@ -239,19 +191,19 @@ func processClassType(node map[string]interface{}, addNamePrefix string) (CppCla
 
 	// Check if this was 'struct' (default public) or 'class' (default private)
 	visibility := VsPublic
-	if tagUsed, ok := node["tagUsed"].(string); ok && tagUsed == "class" {
+	if tagUsed, ok := node.Fields["tagUsed"].(string); ok && tagUsed == "class" {
 		visibility = VsPrivate
 	}
 
 	// Check if this is an abstract class
-	if definitionData, ok := node["definitionData"].(map[string]interface{}); ok {
+	if definitionData, ok := node.Fields["definitionData"].(map[string]interface{}); ok {
 		if isAbstract, ok := definitionData["isAbstract"].(bool); ok && isAbstract {
 			ret.Abstract = true
 		}
 	}
 
 	// Check if this (publicly) inherits another class
-	if bases, ok := node["bases"].([]interface{}); ok {
+	if bases, ok := node.Fields["bases"].([]interface{}); ok {
 		for _, base := range bases {
 			base, ok := base.(map[string]interface{})
 			if !ok {
@@ -276,21 +228,12 @@ func processClassType(node map[string]interface{}, addNamePrefix string) (CppCla
 	// Parse all methods
 
 nextMethod:
-	for _, node := range inner {
-		node, ok := node.(map[string]interface{})
-		if !ok {
-			return CppClass{}, errors.New("inner[] element not an object")
-		}
-
-		kind, ok := node["kind"].(string)
-		if !ok {
-			panic("inner element has no kind")
-		}
-
+	for _, node := range node.Inner {
+		kind := node.Kind
 		switch kind {
 		case "AccessSpecDecl":
 			// Swap between visible/invisible
-			access, ok := node["access"].(string)
+			access, ok := node.Fields["access"].(string)
 			if !ok {
 				panic("AccessSpecDecl missing `access` field")
 			}
@@ -309,7 +252,7 @@ nextMethod:
 			// Clang sees Q_SIGNALS/signals as being a macro for `public`
 			// If this AccessSpecDecl was imported from a macro, assume it's signals
 			isSignal = false
-			if loc, ok := node["loc"].(map[string]interface{}); ok {
+			if loc, ok := node.Fields["loc"].(map[string]interface{}); ok {
 				if _, ok := loc["expansionLoc"].(map[string]interface{}); ok {
 					isSignal = true
 				}
@@ -359,13 +302,14 @@ nextMethod:
 			if err != nil {
 				panic(fmt.Errorf("processEnum: %w", err)) // A real problem
 			}
+
 			if len(en.Entries) > 0 { // e.g. qmetatype's version of QCborSimpleType (the real one is in qcborcommon)
 				ret.ChildEnums = append(ret.ChildEnums, en)
 			}
 
 		case "CXXConstructorDecl":
 
-			if isImplicit, ok := node["isImplicit"].(bool); ok && isImplicit {
+			if isImplicit, ok := node.Fields["isImplicit"].(bool); ok && isImplicit {
 				// This is an implicit ctor. Therefore the class is constructable
 				// even if we're currently in a `private:` block.
 
@@ -406,7 +350,7 @@ nextMethod:
 			// However if this destructor is private or deleted, we should
 			// not bind it
 
-			if isImplicit, ok := node["isImplicit"].(bool); ok && isImplicit {
+			if isImplicit, ok := node.Fields["isImplicit"].(bool); ok && isImplicit {
 				// This is an implicit dtor. Therefore the class is deleteable
 				// even if we're currently in a `private:` block.
 				ret.CanDelete = true
@@ -429,7 +373,7 @@ nextMethod:
 			"CXXConversionDecl": // e.g. `QColor::operator QVariant()`
 
 			// Method
-			methodName, ok := node["name"].(string)
+			methodName, ok := node.Fields["name"].(string)
 			if !ok {
 				return CppClass{}, errors.New("method has no name")
 			}
@@ -511,13 +455,13 @@ nextMethod:
 }
 
 // isExplicitlyDeleted checks if this node is marked `= delete`.
-func isExplicitlyDeleted(node map[string]interface{}) bool {
+func isExplicitlyDeleted(node *AstNode) bool {
 
-	if explicitlyDeleted, ok := node["explicitlyDeleted"].(bool); ok && explicitlyDeleted {
+	if explicitlyDeleted, ok := node.Fields["explicitlyDeleted"].(bool); ok && explicitlyDeleted {
 		return true
 	}
 
-	if explicitlyDefaulted, ok := node["explicitlyDefaulted"].(string); ok && explicitlyDefaulted == "deleted" {
+	if explicitlyDefaulted, ok := node.Fields["explicitlyDefaulted"].(string); ok && explicitlyDefaulted == "deleted" {
 		return true
 	}
 
@@ -536,19 +480,19 @@ func isPrivateSignal(method *CppMethod) (int, bool) {
 }
 
 // processEnum parses a Clang enum into our CppEnum intermediate format.
-func processEnum(node map[string]interface{}, addNamePrefix string) (CppEnum, error) {
-	var ret CppEnum
+func processEnum(node *AstNode, addNamePrefix string) (CppEnum, error) {
+	var ret = CppEnum{}
 
 	// Underlying type
 	ret.UnderlyingType = parseSingleTypeString("int")
-	if nodefut, ok := node["fixedUnderlyingType"].(map[string]interface{}); ok {
+	if nodefut, ok := node.Fields["fixedUnderlyingType"].(map[string]interface{}); ok {
 		if nodequal, ok := nodefut["qualType"].(string); ok {
 			ret.UnderlyingType = parseSingleTypeString(nodequal)
 		}
 	}
 
 	// Name
-	nodename, ok := node["name"].(string)
+	nodename, ok := node.Fields["name"].(string)
 	if !ok {
 		// An unnamed enum is possible (e.g. qcalendar.h)
 		// It defines integer constants just in the current scope
@@ -559,23 +503,17 @@ func processEnum(node map[string]interface{}, addNamePrefix string) (CppEnum, er
 	}
 
 	// Entries
-	inner, ok := node["inner"].([]interface{})
-	if !ok {
-		// An enum with no entries? We're done
+	if len(node.Inner) == 0 {
+		// This is either a forward declaration or an empty enum
 		return ret, nil
 	}
 
 	var lastImplicitValue int64 = -1
 
 nextEnumEntry:
-	for _, entry := range inner {
-		entry, ok := entry.(map[string]interface{})
-		if !ok {
-			return ret, errors.New("bad inner type")
-		}
-
-		kind, ok := entry["kind"].(string)
-		if kind == "DeprecatedAttr" || kind == "FullComment" {
+	for _, entry := range node.Inner {
+		kind := entry.Kind
+		if kind == "DeprecatedAttr" || kind == "FullComment" || kind == "VisibilityAttr" {
 			continue nextEnumEntry // skip
 		} else if kind == "EnumConstantDecl" {
 			// allow
@@ -586,7 +524,7 @@ nextEnumEntry:
 
 		var cee CppEnumEntry
 
-		entryname, ok := entry["name"].(string)
+		entryname, ok := entry.Fields["name"].(string)
 		if !ok {
 			return ret, errors.New("entry without name")
 		}
@@ -594,7 +532,7 @@ nextEnumEntry:
 		cee.EntryName = entryname
 
 		// Try to find the enum value
-		ei1, ok := entry["inner"].([]interface{})
+		ei1 := entry.Inner
 		if !ok {
 			// No inner value on the enum = autoincrement
 			// Fall through as if a blank ei1, this will be handled
@@ -606,12 +544,7 @@ nextEnumEntry:
 		// work for the purposes of enum constant value parsing
 		foundValidInner := false
 		for _, ei1_0 := range ei1 {
-
-			ei1_0 := ei1_0.(map[string]interface{})
-			ei1Kind, ok := ei1_0["kind"].(string)
-			if !ok {
-				panic("inner with no kind (1)")
-			}
+			ei1Kind := ei1_0.Kind
 
 			if ei1Kind == "FullComment" {
 				continue
@@ -621,8 +554,7 @@ nextEnumEntry:
 			// Best case: .inner -> kind=ConstantExpr value=xx
 			// e.g. qabstractitemmodel
 			if ei1Kind == "ConstantExpr" {
-				log.Printf("Got ConstantExpr OK")
-				if ei1Value, ok := ei1_0["value"].(string); ok {
+				if ei1Value, ok := ei1_0.Fields["value"].(string); ok {
 					cee.EntryValue = ei1Value
 					goto afterParse
 				}
@@ -631,10 +563,10 @@ nextEnumEntry:
 			// Best case: .inner -> kind=ImplicitCastExpr .inner -> kind=ConstantExpr value=xx
 			// e.g. QCalendar (when there is a int typecast)
 			if ei1Kind == "ImplicitCastExpr" {
-				if ei2, ok := ei1_0["inner"].([]interface{}); ok && len(ei2) > 0 {
-					ei2_0 := ei2[0].(map[string]interface{})
-					if ei2Kind, ok := ei2_0["kind"].(string); ok && ei2Kind == "ConstantExpr" {
-						if ei2Value, ok := ei2_0["value"].(string); ok {
+				if ei2 := ei1_0.Inner; ok && len(ei2) > 0 {
+					ei2_0 := ei2[0]
+					if ei2_0.Kind == "ConstantExpr" {
+						if ei2Value, ok := ei2_0.Fields["value"].(string); ok {
 							cee.EntryValue = ei2Value
 							goto afterParse
 						}
@@ -679,9 +611,9 @@ nextEnumEntry:
 }
 
 // parseMethod parses a Clang method into our CppMethod intermediate format.
-func parseMethod(node map[string]interface{}, mm *CppMethod) error {
+func parseMethod(node *AstNode, mm *CppMethod) error {
 
-	if typobj, ok := node["type"].(map[string]interface{}); ok {
+	if typobj, ok := node.Fields["type"].(map[string]interface{}); ok {
 		if qualType, ok := typobj["qualType"].(string); ok {
 			// The qualType is the whole type of the method, including its parameter types
 			// If anything here is too complicated, skip the whole method
@@ -691,34 +623,28 @@ func parseMethod(node map[string]interface{}, mm *CppMethod) error {
 			if err != nil {
 				return err
 			}
-
 		}
 	}
 
-	if storageClass, ok := node["storageClass"].(string); ok && storageClass == "static" {
+	if storageClass, ok := node.Fields["storageClass"].(string); ok && storageClass == "static" {
 		mm.IsStatic = true
 	}
 
-	if virtual, ok := node["virtual"].(bool); ok && virtual {
+	if virtual, ok := node.Fields["virtual"].(bool); ok && virtual {
 		mm.IsVirtual = true
 	}
 
-	if pure, ok := node["pure"].(bool); ok && pure {
+	if pure, ok := node.Fields["pure"].(bool); ok && pure {
 		mm.IsPureVirtual = true
 	}
 
-	if methodInner, ok := node["inner"].([]interface{}); ok {
+	if methodInner := node.Inner; len(methodInner) > 0 {
 		paramCounter := 0
 		for _, methodObj := range methodInner {
-			methodObj, ok := methodObj.(map[string]interface{})
-			if !ok {
-				return errors.New("inner[] element not an object")
-			}
-
-			switch methodObj["kind"] {
+			switch methodObj.Kind {
 			case "ParmVarDecl":
 				// Parameter variable
-				parmName, _ := methodObj["name"].(string) // n.b. may be unnamed
+				parmName, _ := methodObj.Fields["name"].(string) // n.b. may be unnamed
 				if parmName == "" {
 
 					// Generate a default parameter name
@@ -737,7 +663,7 @@ func parseMethod(node map[string]interface{}, mm *CppMethod) error {
 
 				// If this parameter has any internal AST nodes of its
 				// own, assume it means it's an optional parameter
-				if _, ok := methodObj["inner"]; ok {
+				if len(methodObj.Inner) > 0 {
 					mm.Parameters[paramCounter].Optional = true
 				}
 
@@ -752,7 +678,7 @@ func parseMethod(node map[string]interface{}, mm *CppMethod) error {
 
 			default:
 				// Something else inside a declaration??
-				log.Printf("==> NOT IMPLEMENTED CXXMethodDecl->%q\n", methodObj["kind"])
+				log.Printf("==> NOT IMPLEMENTED CXXMethodDecl->%q\n", methodObj.Kind)
 			}
 		}
 	}

cmd/genbindings/clangast.go

@@ -0,0 +1,347 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func isSourceLoc(field string) bool {
+	// "file" (and "line" which we don't care about) takes on the last observed
+	// value for certain node kinds - to simplify processing, we expand it in the
+	// parsed AST.
+	// https://github.com/dtolnay/clang-ast?tab=readme-ov-file#source-locations
+	// https://github.com/llvm/llvm-project/blob/26d9cb17a6e655993c991b66b21d5c378256d79b/clang/lib/AST/JSONNodeDumper.cpp#L285
+	switch field {
+	case "loc", "spellingLoc", "expansionLoc", "begin", "end", "attrLoc":
+		return true
+	}
+
+	return false
+}
+
+// HexUint64 is a uint64 that marshals to/from JSON as a hex string.
+type HexUint64 uint64
+
+func (h HexUint64) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("\"0x%x\"", uint64(h))), nil
+}
+
+func (h *HexUint64) UnmarshalJSON(data []byte) error {
+	var s string
+	if err := json.Unmarshal(data, &s); err != nil {
+		return err
+	}
+	val, err := strconv.ParseUint(strings.TrimPrefix(s, "0x"), 16, 64)
+	if err != nil {
+		return err
+	}
+	*h = HexUint64(val)
+	return nil
+}
+
+func (h HexUint64) String() string {
+	return fmt.Sprintf("0x%x", uint64(h))
+}
+
+type AstNode struct {
+	Id    HexUint64  `json:"id"`
+	Kind  string     `json:"kind"`
+	Inner []*AstNode `json:"inner,omitempty"`
+	// Additional information depending on the node kind - in the original clang
+	// AST, there is no nesting in an additional `fields` object but we do so
+	// here to simplify the caching code which otherwise would require more of the
+	// kind of custom marshalling that we're trying to avoid
+	Fields map[string]interface{} `json:"fields,omitempty"`
+}
+
+// User-provided function that returns true if the inner array should be parsed for a given kind.
+// Return `false` to skip parsing the inner array and save some CPU cycles / memory.
+type ShouldParseInner func(ctx *ParseCtx, kind string) bool
+
+// User-provided function that returns true if the field should be added to `Fields“.
+type ShouldKeepField func(ctx *ParseCtx, kind, field string, value interface{}) bool
+
+// User-provided function for discarding inner nodes that turn out to be superfluous
+// and therefore should not be added to `Inner`.
+type ShouldKeepInner func(ctx *ParseCtx, parentKind string, child *AstNode) bool
+
+type ParseCtx struct {
+	dec              *json.Decoder
+	stack            []*AstNode
+	file             string // Last observed file value ("line" works the same but we don't need it)
+	ShouldParseInner ShouldParseInner
+	ShouldKeepField  ShouldKeepField
+	ShouldKeepInner  ShouldKeepInner
+}
+
+// unmarshalWithFile decodes the next value from ctx.dec similar to Decode.
+// It updates ctx.file if a "file" key is encountered in a source location.
+func unmarshalWithFile(ctx *ParseCtx, sourceLoc bool) (interface{}, error) {
+	tok, err := ctx.dec.Token()
+	if err != nil {
+		return nil, err
+	}
+	switch v := tok.(type) {
+	case json.Delim:
+		switch v {
+		case '{':
+			// Parse object
+			m := make(map[string]interface{})
+			hasFileField := false
+			subLoc := false
+			for ctx.dec.More() {
+				keyTok, err := ctx.dec.Token()
+				if err != nil {
+					return nil, err
+				}
+				key, ok := keyTok.(string)
+				if !ok {
+					return nil, fmt.Errorf("expected string key in object, got %v", keyTok)
+				}
+				val, err := unmarshalWithFile(ctx, isSourceLoc(key))
+				if err != nil {
+					return nil, err
+				}
+				m[key] = val
+
+				if sourceLoc {
+					if key == "file" {
+						ctx.file = val.(string)
+						hasFileField = true
+
+					} else if key == "spellingLoc" {
+						subLoc = true
+					}
+				}
+			}
+			// Consume closing '}'
+			endTok, err := ctx.dec.Token()
+			if err != nil {
+				return nil, err
+			}
+			if endDelim, ok := endTok.(json.Delim); !ok || endDelim != '}' {
+				return nil, fmt.Errorf("expected '}', got %v", endTok)
+			}
+			if sourceLoc && !hasFileField && !subLoc {
+				// If the file is not present, use the last observed value
+				m["file"] = ctx.file
+			}
+
+			return m, nil
+		case '[':
+			// Parse array
+			var arr []interface{}
+			for ctx.dec.More() {
+				val, err := unmarshalWithFile(ctx, false)
+				if err != nil {
+					return nil, err
+				}
+				arr = append(arr, val)
+			}
+			// Consume closing ']'
+			endTok, err := ctx.dec.Token()
+			if err != nil {
+				return nil, err
+			}
+			if endDelim, ok := endTok.(json.Delim); !ok || endDelim != ']' {
+				return nil, fmt.Errorf("expected ']', got %v", endTok)
+			}
+			return arr, nil
+		default:
+			return nil, fmt.Errorf("unexpected delimiter %v", v)
+		}
+	case string, float64, bool, nil:
+		return v, nil
+	default:
+		return nil, fmt.Errorf("unexpected token type %T", v)
+	}
+}
+
+// skipWithFile skips the next value from ctx.dec while updating ctx.file.
+func skipWithFile(ctx *ParseCtx, sourceLoc bool) error {
+	tok, err := ctx.dec.Token()
+	if err != nil {
+		return err
+	}
+	switch v := tok.(type) {
+	case json.Delim:
+		switch v {
+		case '{':
+			// Parse object
+			for ctx.dec.More() {
+				keyTok, err := ctx.dec.Token()
+				if err != nil {
+					return err
+				}
+				key, ok := keyTok.(string)
+				if !ok {
+					return fmt.Errorf("expected string key in object, got %v", keyTok)
+				}
+
+				if sourceLoc && key == "file" {
+					val, err := ctx.dec.Token()
+					if err != nil {
+						return err
+					}
+					if _, ok := val.(string); !ok {
+						return fmt.Errorf("expected string value for file, got %v", val)
+					}
+					ctx.file = val.(string)
+				} else {
+					err = skipWithFile(ctx, isSourceLoc(key))
+					if err != nil {
+						return err
+					}
+				}
+			}
+			// Consume closing '}'
+			endTok, err := ctx.dec.Token()
+			if err != nil {
+				return err
+			}
+			if endDelim, ok := endTok.(json.Delim); !ok || endDelim != '}' {
+				return fmt.Errorf("expected '}', got %v", endTok)
+			}
+
+			return nil
+		case '[':
+			// Parse array
+			for ctx.dec.More() {
+				err := skipWithFile(ctx, false)
+				if err != nil {
+					return err
+				}
+			}
+			// Consume closing ']'
+			endTok, err := ctx.dec.Token()
+			if err != nil {
+				return err
+			}
+			if endDelim, ok := endTok.(json.Delim); !ok || endDelim != ']' {
+				return fmt.Errorf("expected ']', got %v", endTok)
+			}
+			return nil
+		default:
+			return fmt.Errorf("unexpected delimiter %v", v)
+		}
+	case string, float64, bool, nil:
+		return nil
+	default:
+		return fmt.Errorf("unexpected token type %T", v)
+	}
+}
+
+// Parse the clang AST while taking into account that unlike standard JSON, the
+// encoding relies on field ordering to skip redundant fields - in particular
+// source locations. As such, we have to use a custom parser in which we process
+// the fields in order while re-adding the stripped fields thus aiding further
+// processing.
+func parseClangAst(ctx *ParseCtx) (*AstNode, error) {
+	// Expect start of object
+	tok, err := ctx.dec.Token()
+	if err != nil {
+		return nil, err
+	}
+	if delim, ok := tok.(json.Delim); !ok || delim != '{' {
+		return nil, fmt.Errorf("expected '{', got %v", tok)
+	}
+
+	node := &AstNode{}
+
+	for ctx.dec.More() {
+		fieldTok, err := ctx.dec.Token()
+		if err != nil {
+			return nil, err
+		}
+		field, ok := fieldTok.(string)
+		if !ok {
+			return nil, fmt.Errorf("expected string for field name, got %v", fieldTok)
+		}
+
+		switch field {
+		case "id":
+			var idStr string
+			if err := ctx.dec.Decode(&idStr); err != nil {
+				return nil, err
+			}
+			id, err := strconv.ParseUint(strings.TrimPrefix(idStr, "0x"), 16, 64)
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse id %q as hex: %w", idStr, err)
+			}
+			node.Id = HexUint64(id)
+		case "kind":
+			var kind string
+			if err := ctx.dec.Decode(&kind); err != nil {
+				return nil, err
+			}
+			node.Kind = kind
+
+		case "inner":
+			if ctx.ShouldParseInner != nil && !ctx.ShouldParseInner(ctx, node.Kind) {
+				if err := skipWithFile(ctx, false); err != nil {
+					return nil, err
+				}
+			} else {
+				ctx.stack = append(ctx.stack, node)
+
+				// Expect start of array
+				tok, err := ctx.dec.Token()
+				if err != nil {
+					return nil, err
+				}
+				if delim, ok := tok.(json.Delim); !ok || delim != '[' {
+					return nil, fmt.Errorf("expected '[', got %v", tok)
+				}
+				var innerNodes []*AstNode
+				for ctx.dec.More() {
+					child, err := parseClangAst(ctx)
+					if err != nil {
+						return nil, err
+					}
+					// Filter inner nodes if callback is set
+					if ctx.ShouldKeepInner == nil || ctx.ShouldKeepInner(ctx, node.Kind, child) {
+						innerNodes = append(innerNodes, child)
+					}
+				}
+				// Expect end of array
+				tok, err = ctx.dec.Token()
+				if err != nil {
+					return nil, err
+				}
+				if delim, ok := tok.(json.Delim); !ok || delim != ']' {
+					return nil, fmt.Errorf("expected ']', got %v", tok)
+				}
+
+				ctx.stack = ctx.stack[:len(ctx.stack)-1]
+				node.Inner = innerNodes
+			}
+		default:
+			// Collect unknown fields, allocate map only if needed
+			val, err := unmarshalWithFile(ctx, isSourceLoc(field))
+			if err != nil {
+				panic(err)
+			}
+			// Filter unknown fields if callback is set
+			if ctx.ShouldKeepField == nil || ctx.ShouldKeepField(ctx, node.Kind, field, val) {
+				if node.Fields == nil {
+					node.Fields = make(map[string]interface{})
+				}
+
+				node.Fields[field] = val
+			}
+		}
+	}
+	// Expect end of object
+	tok, err = ctx.dec.Token()
+	if err != nil {
+		return nil, err
+	}
+
+	if delim, ok := tok.(json.Delim); !ok || delim != '}' {
+		return nil, fmt.Errorf("expected '}', got %v", tok)
+	}
+
+	return node, nil
+}

cmd/genbindings/clangexec.go

@@ -1,173 +1,40 @@
 package main
 
 import (
-	"context"
-	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"log"
 	"os"
 	"os/exec"
-	"strings"
-	"sync"
-	"time"
 )
 
-const (
-	ClangMaxRetries = 5
-	ClangRetryDelay = 3 * time.Second
-)
-
-type ClangMatcher func(astNodeFilename string) bool
-
-func ClangMatchSameHeaderDefinitionOnly(astNodeFilename string) bool {
-	return astNodeFilename == ""
-}
-
-type clangMatchUnderPath struct {
-	basePath string
-}
-
-func (c *clangMatchUnderPath) Match(astNodeFilename string) bool {
-	if astNodeFilename == "" {
-		return true
-	}
-	return strings.HasPrefix(astNodeFilename, c.basePath)
-}
-
-//
-
-func clangExec(ctx context.Context, clangBin, inputHeader string, cflags []string, matcher ClangMatcher) ([]interface{}, error) {
-
+func clangExec(clangBin, inputHeader string, cflags []string) (*AstNode, error) {
 	clangArgs := []string{`-x`, `c++`}
 	clangArgs = append(clangArgs, cflags...)
 	clangArgs = append(clangArgs, `-Xclang`, `-ast-dump=json`, `-fsyntax-only`, inputHeader)
 
-	cmd := exec.CommandContext(ctx, clangBin, clangArgs...)
-	pr, err := cmd.StdoutPipe()
-	if err != nil {
-		return nil, fmt.Errorf("StdoutPipe: %w", err)
-	}
+	log.Printf("clang args: %s", clangArgs)
 
+	cmd := exec.Command(clangBin, clangArgs...)
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		return nil, fmt.Errorf("could not create stdout pipe for clang: %w", err)
+	}
 	cmd.Stderr = os.Stderr
 
-	err = cmd.Start()
+	if err := cmd.Start(); err != nil {
+		return nil, fmt.Errorf("could not start clang: %w", err)
+	}
+
+	ast, err := filterAst(stdout)
+
 	if err != nil {
-		return nil, fmt.Errorf("Start: %w", err)
+		return nil, fmt.Errorf("could not parse clang AST: %w", err)
 	}
 
-	var wg sync.WaitGroup
-	var inner []interface{}
-	var innerErr error
-
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		inner, innerErr = clangStripUpToFile(pr, matcher)
-	}()
-
-	// Go documentation says: only call cmd.Wait once all reads from the
-	// StdoutPipe have completed
-	wg.Wait()
-
-	err = cmd.Wait()
-	if err != nil {
-		return nil, fmt.Errorf("Command: %w", err)
+	if err := cmd.Wait(); err != nil {
+		return nil, fmt.Errorf("could not wait for clang: %w", err)
 	}
 
-	return inner, innerErr
-}
-
-func mustClangExec(ctx context.Context, clangBin, inputHeader string, cflags []string, matcher ClangMatcher) []interface{} {
-
-	for i := 0; i < ClangMaxRetries; i++ {
-		astInner, err := clangExec(ctx, clangBin, inputHeader, cflags, matcher)
-		if err != nil {
-			// Log and continue with next retry
-			log.Printf("WARNING: Clang execution failed: %v", err)
-			time.Sleep(ClangRetryDelay)
-			log.Printf("Retrying...")
-			continue
-		}
-
-		// Success
-		return astInner
-	}
-
-	// Failed 5x
-	// Panic
-	panic("Clang failed 5x parsing file " + inputHeader)
-}
-
-// clangStripUpToFile strips all AST nodes from the clang output until we find
-// one that really originated in the source file.
-// This cleans out everything in the translation unit that came from an
-// #included file.
-// @ref https://stackoverflow.com/a/71128654
-func clangStripUpToFile(stdout io.Reader, matcher ClangMatcher) ([]interface{}, error) {
-
-	var obj = map[string]interface{}{}
-	err := json.NewDecoder(stdout).Decode(&obj)
-	if err != nil {
-		return nil, fmt.Errorf("json.Decode: %v", err)
-	}
-
-	inner, ok := obj["inner"].([]interface{})
-	if !ok {
-		return nil, errors.New("no inner")
-	}
-
-	// This can't be done by matching the first position only, since it's possible
-	// that there are more #include<>s further down the file
-
-	ret := make([]interface{}, 0, len(inner))
-
-	for _, entry := range inner {
-
-		entry, ok := entry.(map[string]interface{})
-		if !ok {
-			return nil, errors.New("entry is not a map")
-		}
-
-		// Check where this AST node came from, if it was directly written
-		// in this header or if it as part of an #include
-
-		var match_filename = ""
-
-		if loc, ok := entry["loc"].(map[string]interface{}); ok {
-			if includedFrom, ok := loc["includedFrom"].(map[string]interface{}); ok {
-				if filename, ok := includedFrom["file"].(string); ok {
-					match_filename = filename
-				}
-			}
-
-			if match_filename == "" {
-				if expansionloc, ok := loc["expansionLoc"].(map[string]interface{}); ok {
-					if filename, ok := expansionloc["file"].(string); ok {
-						match_filename = filename
-
-					} else if includedFrom, ok := expansionloc["includedFrom"].(map[string]interface{}); ok {
-						if filename, ok := includedFrom["file"].(string); ok {
-							match_filename = filename
-						}
-					}
-				}
-			}
-		} else {
-			return nil, errors.New("no loc")
-		}
-
-		// log.Printf("# name=%v kind=%v filename=%q\n", entry["name"], entry["kind"], match_filename)
-
-		if matcher(match_filename) {
-			// Keep
-			ret = append(ret, entry)
-		}
-
-		// Otherwise, discard this AST node, it comes from some imported file
-		// that we will likely scan separately
-	}
-
-	return ret, nil
+	return ast, nil
 }

cmd/genbindings/clangfilter.go

@@ -0,0 +1,282 @@
+package main
+
+import (
+	"compress/gzip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"strings"
+)
+
+func filteredAstPath(inputHeader string) string {
+	return cacheFileRoot(inputHeader) + ".filtered.json.gz"
+}
+
+func dumpStack(stack []*AstNode) string {
+	var ret string
+	for i := len(stack) - 1; i >= 0; i-- {
+		ret += "<" + stack[i].Kind
+	}
+	return ret
+}
+
+func allowExpressions(stack []*AstNode) bool {
+	// In a few exceptional cases, we parse the full expression - not because we
+	// really need it but because it's easier to filter it out later
+
+	for _, node := range stack {
+		if node.Kind == "ParmVarDecl" || node.Kind == "EnumConstantDecl" {
+			return true
+		}
+	}
+	return false
+}
+
+func parseInner(ctx *ParseCtx, kind string) bool {
+	// Return false for all the kinds whose inner nodes we don't care about
+	// at all - this is a performance optimization
+	switch kind {
+	case "TranslationUnitDecl", "NamespaceDecl":
+		return true
+	case "CXXRecordDecl", "EnumDecl", "EnumConstantDecl": // methods, fields, elements etc
+		return true
+	case "CXXConstructorDecl", "CXXMethodDecl", "CXXConversionDecl":
+		// Parameters, return type - skip when it's outside of a class declaration
+		return ctx.stack[len(ctx.stack)-1].Kind == "CXXRecordDecl"
+	case "CXXDestructorDecl":
+		return false
+	case "ParmVarDecl": // Parameter defaults
+		return true
+	case "TypeAliasDecl", "TypedefDecl": // Can extract from Fields
+		return false
+	case "CompoundStmt", "CXXCtorInitializer": // Bodies
+		return false
+	case "LinkageSpecDecl", "FunctionDecl", "AccessSpecDecl", "VarDecl", "FieldDecl",
+		"FileScopeAsmDecl", "FriendDecl", "UsingShadowDecl", "UsingDecl",
+		"StaticAssertDecl", "ElaboratedType", "FullComment", "ParagraphComment",
+		"EmptyDecl", "IndirectFieldDecl":
+		return false
+	case "ClassTemplateDecl", "TypeAliasTemplateDecl",
+		"ClassTemplateSpecializationDecl",
+		"ClassTemplatePartialSpecializationDecl", "FunctionTemplateDecl",
+		"VarTemplatePartialSpecializationDecl",
+		"VarTemplateSpecializationDecl", // e.g. qhashfunctions.h
+		"VarTemplateDecl", "BuiltinTemplateDecl":
+		return false // TODO template instantiations
+	case "ConstantExpr":
+		return true // Enum values / constants / etc
+	case "ImplicitCastExpr", "IntegerLiteral", "ParenExpr":
+		// Things we have observed in a constant expression
+		return true
+	case "ConstructorUsingShadowDecl":
+		// TODO using Base::Base(...)-style constructors
+		return false
+	}
+
+	if strings.HasSuffix(kind, "Attr") {
+		return false
+	}
+
+	if allowExpressions(ctx.stack) {
+		return true
+	}
+
+	log.Printf("clangfilter: unknown inner kind %s%v", kind, dumpStack(ctx.stack))
+	return true
+}
+
+func keepField(ctx *ParseCtx, kind, field string, val interface{}) bool {
+	switch field {
+	case "loc":
+		switch kind {
+		case "TranslationUnitDecl", "NamespaceDecl", "CXXRecordDecl", "EnumDecl",
+			"TypeAliasDecl", "TypedefDecl":
+			// only needed in parseHeader
+			return true
+		case "AccessSpecDecl":
+			// Signal detection
+			return true
+		}
+
+		return false
+
+	case "name", "type", "tagUsed", "definitionData", "bases", "access",
+		"isImplicit", "explicitlyDeleted", "explicitlyDefaulted",
+		"fixedUnderlyingType", "value", "storageClass", "virtual", "pure",
+		"file":
+		return true
+	case "range": // extended version of loc
+		return false
+	case "isReferenced", "language", "previousDecl", "originalNamespace", "isInline",
+		"isUsed", "mangledName", "inline", "constexpr", "parentDeclContextId",
+		"completeDefinition", "variadic", "target", "hasBraces", "init", "baseInit",
+		"nominatedNamespace", "implicit", "anyInit", "valueCategory", "castKind",
+		"scopedEnumTag", "argType", "opcode", "referencedDecl", "hasInClassInitializer",
+		"isPostfix", "canOverflow", "ctorType", "elidable", "hadMultipleCandidates",
+		"storageDuration", "conversionFunc", "constructionKind", "ownedTagDecl",
+		"isBitfield", "delegatingInit", "mutable", "boundToLValueRef",
+		"cleanupsHaveSideEffects", "temp", "dtor", "inherited", "isPartOfExplicitCast",
+		"adl", "decl", "list", "tls", "nonOdrUseReason", "zeroing":
+		return false
+	}
+	log.Printf("clangfilter: unknown field %v %v%v", field, kind, dumpStack(ctx.stack))
+	return true
+}
+
+func keepInner(ctx *ParseCtx, parentKind string, child *AstNode) bool {
+	// Nodes that we want to add to the inner array of their parent
+	switch child.Kind {
+	case "NamespaceDecl", "CXXRecordDecl", "EnumDecl", "TypeAliasDecl", "TypedefDecl",
+		"ParmVarDecl":
+		return true
+
+	case "StaticAssertDecl", "ClassTemplateDecl",
+		"ClassTemplateSpecializationDecl",
+		"ClassTemplatePartialSpecializationDecl",
+		"FunctionTemplateDecl",
+		"BuiltinTemplateDecl",                  // Scintilla
+		"VarTemplatePartialSpecializationDecl", // e.g. Qt6 qcontainerinfo.h
+		"VarTemplateSpecializationDecl",        // e.g. qhashfunctions.h
+		"TypeAliasTemplateDecl",                // e.g. qendian.h
+		"VarTemplateDecl",                      // e.g. qglobal.h
+		// Template stuff probably can't be supported in the binding since
+		// we would need to link a concrete instantiation for each type in
+		// the CABI
+		"FileScopeAsmDecl",
+		"FunctionDecl",
+		"FriendDecl", // TODO
+		"ElaboratedType":
+		return false
+	case "VarDecl", "FieldDecl", "IndirectFieldDecl":
+		// TODO e.g. qmath.h
+		// We could probably generate setter/getter for this in the CABI
+		return parentKind == "CXXRecordDecl"
+
+	case "CXXConstructorDecl", "CXXMethodDecl", "CXXConversionDecl", "CXXDestructorDecl":
+		return parentKind == "CXXRecordDecl"
+
+	case "LinkageSpecDecl":
+		// TODO e.g. qfuturewatcher.h
+		// Probably can't be supported in the Go binding
+		return false
+
+	case "OverrideAttr", "DeprecatedAttr":
+		return true
+	case "AccessSpecDecl":
+		return parentKind == "CXXRecordDecl"
+	case "UsingDirectiveDecl", // qtextstream.h
+		"UsingDecl",       // qglobal.h
+		"UsingShadowDecl": // global.h
+		// TODO e.g.
+		// Should be treated like a typedef
+		return false
+	case "FullComment", "ParagraphComment", "EmptyDecl":
+		// Safe to skip
+		return false
+	case "CompoundStmt", "CXXCtorInitializer":
+		return false
+	case "EnumConstantDecl":
+		return true // Enum values
+	case "ConstructorUsingShadowDecl":
+		// TODO using Base::Base(...)-style constructors
+		return false
+	}
+
+	if strings.HasSuffix(child.Kind, "Attr") {
+		return false
+	}
+
+	if allowExpressions(ctx.stack) {
+		return true
+	}
+
+	log.Printf("clangfilter: unknown child node kind %s%v", child.Kind, dumpStack(ctx.stack))
+	return true
+}
+
+func filterAst(in io.Reader) (*AstNode, error) {
+	// Filter an AST as produced by `clang -x c++ -Xclang -ast-dump=json` to focus
+	// on the information needed to generate a wrapper - implementations, source
+	// code locations etc are broadly not used in the later stages.
+	var pc = ParseCtx{
+		dec:              json.NewDecoder(in),
+		ShouldParseInner: parseInner,
+		ShouldKeepField:  keepField,
+		ShouldKeepInner:  keepInner,
+	}
+
+	return parseClangAst(&pc)
+}
+
+func writeCache(ast *AstNode, inputHeader string) {
+	// Write a compressed version of the AST to disk - the AST is generally
+	// highly redundant a compresses by a factor of 10-20x - the typical Qt file
+	// is 5-10MB and compresses to ~300-600kB
+	astPath := filteredAstPath(inputHeader)
+	compressedFile, err := os.Create(astPath)
+	if err != nil {
+		panic("could not create filtered AST cache for " + inputHeader + ": " + err.Error())
+	}
+	defer compressedFile.Close()
+
+	var gzw = gzip.NewWriter(compressedFile)
+	enc := json.NewEncoder(gzw)
+	enc.SetIndent("", "  ")
+	err = enc.Encode(ast)
+	if err != nil {
+		panic("could not encode filtered AST cache: " + err.Error())
+	}
+
+	err = gzw.Close()
+	if err != nil {
+		panic("could not complete write to AST cache file: " + err.Error())
+	}
+}
+
+func readCache(inputHeader string) (*AstNode, error) {
+	compressedFile, err := os.Open(filteredAstPath(inputHeader))
+	if err != nil {
+		return nil, err
+	}
+	defer compressedFile.Close()
+
+	reader, err := gzip.NewReader(compressedFile)
+	if err != nil {
+		return nil, fmt.Errorf("could not create gzip reader for filtered AST cache: %w", err)
+	}
+	defer reader.Close()
+
+	dec := json.NewDecoder(reader)
+
+	var ast *AstNode
+	err = dec.Decode(&ast)
+	if err != nil {
+		return nil, fmt.Errorf("could not decode filtered AST cache: %w", err)
+	}
+	return ast, nil
+}
+
+// Get or create the filtered AST from either the given input header or a version
+// When changing this function, make sure to clear the on-disk cache:
+// rm -rf cachedir/*.filtered.json.gz
+func getFilteredAst(inputHeader, clangBin string, cflags []string) *AstNode {
+	ast, err := readCache(inputHeader)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			panic("could not open filtered AST cache for " + inputHeader + ": " + err.Error())
+		}
+
+		// If the file does not exist, we need to create it
+		// First, we need to create the AST cache
+		ast, err = clangExec(clangBin, inputHeader, cflags)
+		if err != nil {
+			panic("could not create AST cache for " + inputHeader + ": " + err.Error())
+		}
+
+		writeCache(ast, inputHeader)
+	}
+
+	return ast
+}

cmd/genbindings/config-allowlist.go

@@ -54,14 +54,6 @@ func InsertTypedefs(qt6 bool) {
 		KnownTypedefs["QLibraryInfo::LibraryLocation"] = lookupResultTypedef{"qt6", CppTypedef{"QLibraryInfo::LibraryLocation", parseSingleTypeString("QLibraryInfo::LibraryPath")}}
 
 		// Enums
-
-		// QSysInfo.h is being truncated and not finding any content
-		KnownEnums["QSysInfo::Endian"] = lookupResultEnum{"qt6", CppEnum{
-			EnumName: "QSysInfo::Endian",
-			UnderlyingType: CppParameter{
-				ParameterType: "int",
-			},
-		}}
 	}
 
 }
@@ -98,6 +90,8 @@ func Widgets_AllowHeader(fullpath string) bool {
 		"q20iterator.h",                // Qt 6 unstable header
 		"q23functional.h",              // Qt 6 unstable header
 		"qguiapplication_platform.h",   // Qt 6 - can be built for X11 but then platform-specific code fails to build on Windows
+		"qlogging.h",                   // TODO varargs
+		"qstringlist.h",                // handled separately
 		"____last____":
 		return false
 	}
@@ -205,6 +199,9 @@ func AllowClass(className string) bool {
 		"QWebEngineQuotaRequest",     // Qt 6 QWebEngine: Deprecated in Qt 6.9
 
 		"QUntypedPropertyData::InheritsQUntypedPropertyData", // qpropertyprivate.h . Hidden/undocumented class in Qt 6.4, removed in 6.7
+		"QFlag",             // Converted to int
+		"QIncompatibleFlag", // Converted to int
+		"QAtomicInt",        // Unsupported base type
 		"____last____":
 		return false
 	}
@@ -303,6 +300,10 @@ func AllowVirtualForClass(className string) bool {
 		return false
 	}
 
+	if className == "QSqlResult" {
+		return false
+	}
+
 	return true
 }
 

cmd/genbindings/config-libraries.go

@@ -215,6 +215,19 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
 		ClangMatchSameHeaderDefinitionOnly,
 	)
 
+	// Qt 5 SQL
+	// Depends on QtCore
+	generate(
+		"qt/sql",
+		[]string{
+			"/usr/include/x86_64-linux-gnu/qt5/QtSql",
+		},
+		AllowAllHeaders,
+		clangBin,
+		pkgConfigCflags("Qt5Sql"),
+		outDir,
+		ClangMatchSameHeaderDefinitionOnly,
+	)
 
 	// Depends on QtCore/Gui/Widgets, QPrintSupport
 	generate(
@@ -450,7 +463,6 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
 		ClangMatchSameHeaderDefinitionOnly,
 	)
 
-
 	// Qt 6 PDF
 	generate(
 		"qt6/pdf",
@@ -465,7 +477,19 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
 		ClangMatchSameHeaderDefinitionOnly,
 	)
 
-
+	// Qt 6 SQL
+	// Depends on QtCore
+	generate(
+		"qt6/sql",
+		[]string{
+			"/usr/include/x86_64-linux-gnu/qt6/QtSql",
+		},
+		AllowAllHeaders,
+		clangBin,
+		"--std=c++17 "+pkgConfigCflags("Qt6Sql"),
+		outDir,
+		ClangMatchSameHeaderDefinitionOnly,
+	)
 
 	// Qt 6 Charts
 	// Depends on QtCore/Gui/Widgets

cmd/genbindings/intermediate.go

@@ -655,8 +655,13 @@ type CppParsedHeader struct {
 func (c CppParsedHeader) Empty() bool {
 	// If there are only typedefs, that still counts as empty since typedefs
 	// are fully resolved inside genbindings, not exposed in MIQT classes
-
-	return len(c.Enums) == 0 && len(c.Classes) == 0
+	for _, en := range c.Enums {
+		if en.EnumName != "" {
+			// Skip the ones that triggered the astTransformRedundant
+			return false
+		}
+	}
+	return len(c.Classes) == 0
 }
 
 func (c *CppParsedHeader) AddContentFrom(other *CppParsedHeader) {

cmd/genbindings/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"encoding/json"
 	"flag"
 	"fmt"
@@ -15,12 +14,16 @@ import (
 )
 
 const (
-	ClangSubprocessCount = 2
+	MaxClangSubprocessCount = 16
 	BaseModule              = "github.com/mappu/miqt"
 )
 
-func cacheFilePath(inputHeader string) string {
-	return filepath.Join("cachedir", strings.Replace(inputHeader, `/`, `__`, -1)+".json")
+func cacheFileRoot(inputHeader string) string {
+	return filepath.Join("cachedir", strings.Replace(inputHeader, `/`, `__`, -1))
+}
+
+func parsedPath(inputHeader string) string {
+	return cacheFileRoot(inputHeader) + ".ours.json"
 }
 
 func importPathForQtPackage(packageName string) string {
@@ -93,7 +96,41 @@ func pkgConfigCflags(packageName string) string {
 	return string(stdout)
 }
 
-func generate(packageName string, srcDirs []string, allowHeaderFn func(string) bool, clangBin, cflagsCombined, outDir string, matcher ClangMatcher) {
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func parseHeaders(includeFiles []string, clangBin string, cflags []string, matcher HeaderMatcher) []*CppParsedHeader {
+	result := make([]*CppParsedHeader, len(includeFiles))
+
+	// Run clang / parsing in parallel but not too parallel
+	var wg sync.WaitGroup
+	ch := make(chan struct{}, min(runtime.NumCPU(), MaxClangSubprocessCount))
+
+	for i, includeFile := range includeFiles {
+		ch <- struct{}{}
+		wg.Add(1)
+
+		go func(i int, includeFile string) {
+			defer func() {
+				wg.Done()
+				<-ch
+			}()
+
+			result[i] = &CppParsedHeader{Filename: includeFile}
+			ast := getFilteredAst(includeFile, clangBin, cflags)
+			// Convert it to our intermediate format
+			parseHeader(ast, "", result[i], matcher)
+		}(i, includeFile)
+	}
+	wg.Wait()
+	return result
+}
+
+func generate(packageName string, srcDirs []string, allowHeaderFn func(string) bool, clangBin, cflagsCombined, outDir string, matcher HeaderMatcher) {
 
 	var includeFiles []string
 	for _, srcDir := range srcDirs {
@@ -112,51 +149,17 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b
 
 	cleanGeneratedFilesInDir(outDir)
 
-	var processHeaders []*CppParsedHeader
 	atr := astTransformRedundant{
 		preserve: make(map[string]*CppEnum),
 	}
 
 	//
-	// PASS 0 (Fill clang cache)
+	// PASS 1 (Parse headers and generate IL)
 	//
 
-	generateClangCaches(includeFiles, clangBin, cflags, matcher)
-
-	// The cache should now be fully populated.
-
-	//
-	// PASS 1 (clang2il)
-	//
-
-	for _, inputHeader := range includeFiles {
-
-		cacheFile := cacheFilePath(inputHeader)
-
-		astJson, err := os.ReadFile(cacheFile)
-		if err != nil {
-			panic("Expected cache to be created for " + inputHeader + ", but got error " + err.Error())
-		}
-
-		// Json decode
-		var astInner []interface{} = nil
-		err = json.Unmarshal(astJson, &astInner)
-		if err != nil {
-			panic(err)
-		}
-
-		if astInner == nil {
-			panic("Null in cache file for " + inputHeader)
-		}
-
-		// Convert it to our intermediate format
-		parsed, err := parseHeader(astInner, "")
-		if err != nil {
-			panic(err)
-		}
-
-		parsed.Filename = inputHeader // Stash
+	processHeaders := parseHeaders(includeFiles, clangBin, cflags, matcher)
 
+	for _, parsed := range processHeaders {
 		// AST transforms on our IL
 		astTransformChildClasses(parsed)             // must be first
 		astTransformApplyQuirks(packageName, parsed) // must be before optional/overload expansion
@@ -167,8 +170,6 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b
 
 		// Update global state tracker (AFTER astTransformChildClasses)
 		addKnownTypes(packageName, parsed)
-
-		processHeaders = append(processHeaders, parsed)
 	}
 
 	//
@@ -185,15 +186,14 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b
 
 		{
 			// Save the IL file for debug inspection
-			jb, err := json.MarshalIndent(parsed, "", "\t")
-			if err != nil {
-				panic(err)
-			}
-
-			err = os.WriteFile(cacheFilePath(parsed.Filename)+".ours.json", jb, 0644)
+			file, err := os.Create(parsedPath(parsed.Filename))
 			if err != nil {
 				panic(err)
 			}
+			defer file.Close()
+			enc := json.NewEncoder(file)
+			enc.SetIndent("", "\t")
+			enc.Encode(parsed)
 		}
 
 		// Breakout if there is nothing bindable
@@ -268,68 +268,6 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b
 	log.Printf("Processing %d file(s) completed", len(includeFiles))
 }
 
-func generateClangCaches(includeFiles []string, clangBin string, cflags []string, matcher ClangMatcher) {
-
-	var clangChan = make(chan string)
-	var clangWg sync.WaitGroup
-	ctx := context.Background()
-
-	for i := 0; i < ClangSubprocessCount; i++ {
-		clangWg.Add(1)
-		go func() {
-			defer clangWg.Done()
-			log.Printf("Clang worker: starting")
-
-			for {
-				inputHeader, ok := <-clangChan
-				if !ok {
-					return // Done
-				}
-
-				log.Printf("Clang worker got message for file %q", inputHeader)
-
-				// Parse the file
-				// This seems to intermittently fail, so allow retrying
-				astInner := mustClangExec(ctx, clangBin, inputHeader, cflags, matcher)
-
-				// Write to cache
-				jb, err := json.MarshalIndent(astInner, "", "\t")
-				if err != nil {
-					panic(err)
-				}
-
-				err = os.WriteFile(cacheFilePath(inputHeader), jb, 0644)
-				if err != nil {
-					panic(err)
-				}
-
-				astInner = nil
-				jb = nil
-				runtime.GC()
-
-			}
-			log.Printf("Clang worker: exiting")
-		}()
-	}
-
-	for _, inputHeader := range includeFiles {
-
-		// Check if there is a matching cache hit
-		cacheFile := cacheFilePath(inputHeader)
-
-		if _, err := os.Stat(cacheFile); err != nil && os.IsNotExist(err) {
-
-			// Nonexistent cache file, regenerate from clang
-			log.Printf("No AST cache for file %q, running clang...", filepath.Base(inputHeader))
-			clangChan <- inputHeader
-		}
-	}
-
-	// Done with all clang workers
-	close(clangChan)
-	clangWg.Wait()
-}
-
 func main() {
 	// data/time flags make logs hard to compare across runs
 	log.SetFlags(log.Flags() &^ (log.Ldate | log.Ltime))

cmd/genbindings/transformredundant.go

@@ -26,6 +26,7 @@ func (a *astTransformRedundant) Process(parsed *CppParsedHeader) {
 		// Remove from second matched header
 		// This is difficult to manipulate while preserving pointers, so only
 		// wipe out the name and use that as a signal later on
+		// TODO This breaks anonymous enums (such as QTypeInfo)
 		parsed.Enums[i].EnumName = ""
 	}
 }

examples/libraries/qt-sql/main.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"os"
+
+	"github.com/mappu/miqt/qt"
+	"github.com/mappu/miqt/qt/sql"
+)
+
+var mapper *qt.QDataWidgetMapper
+var nextButton *qt.QPushButton
+var previousButton *qt.QPushButton
+var model *sql.QSqlRelationalTableModel
+
+func main() {
+
+	qt.NewQApplication(os.Args)
+
+	widget := qt.NewQWidget2()
+	defer widget.Delete()
+
+	db := sql.QSqlDatabase_AddDatabase("QSQLITE")
+	defer db.Delete()
+
+	db.SetDatabaseName(":memory:")
+	if !db.Open() {
+		qt.QMessageBox_Critical5(
+			widget,
+			"Cannot open database",
+			"Unable to establish a database connection.\nThis example needs SQLite support. Please read the Qt SQL driver documentation for information on how to build it.",
+			qt.QMessageBox__Cancel,
+		)
+		os.Exit(1)
+	}
+
+	query := sql.NewQSqlQuery2()
+	defer query.Delete()
+
+	// Setup the main table
+	query.Exec("create table person (id int primary key, name varchar(20), address varchar(200), typeid int)")
+	query.Exec("insert into person values(1, 'Alice', '<qt>123 Main Street<br/>Market Town</qt>', 101)")
+	query.Exec("insert into person values(2, 'Bob', '<qt>PO Box 32<br/>Mail Handling Service<br/>Service City</qt>', 102)")
+	query.Exec("insert into person values(3, 'Carol', '<qt>The Lighthouse<br/>Remote Island</qt>', 103)")
+	query.Exec("insert into person values(4, 'Donald', '<qt>47338 Park Avenue<br/>Big City</qt>', 101)")
+	query.Exec("insert into person values(5, 'Emma', '<qt>Research Station<br/>Base Camp<br/>Big Mountain</qt>', 103)")
+
+	// Setup the address table
+	query.Exec("create table addresstype (id int, description varchar(20))")
+	query.Exec("insert into addresstype values(101, 'Home')")
+	query.Exec("insert into addresstype values(102, 'Work')")
+	query.Exec("insert into addresstype values(103, 'Other')")
+
+	model = sql.NewQSqlRelationalTableModel2(widget.QObject)
+	model.SetTable("person")
+	model.SetEditStrategy(sql.QSqlTableModel__OnManualSubmit)
+
+	typeIndex := model.FieldIndex("typeid")
+	relation := sql.NewQSqlRelation2("addresstype", "id", "description")
+	defer relation.Delete()
+	model.SetRelation(typeIndex, relation)
+
+	model.Select()
+
+	// Ownership of these widgets will be transferred to the widget via the layout
+	nameLabel := qt.NewQLabel3("Na&me:")
+	nameEdit := qt.NewQLineEdit2()
+	addressLabel := qt.NewQLabel3("&Address:")
+	addressEdit := qt.NewQTextEdit2()
+	typeLabel := qt.NewQLabel3("&Type:")
+	typeComboBox := qt.NewQComboBox2()
+	nextButton = qt.NewQPushButton3("&Next")
+	previousButton = qt.NewQPushButton3("&Previous")
+
+	nameLabel.SetBuddy(nameEdit.QWidget)
+	addressLabel.SetBuddy(addressEdit.QWidget)
+	typeLabel.SetBuddy(typeComboBox.QWidget)
+
+	relModel := model.RelationModel(typeIndex)
+	typeComboBox.SetModel(relModel.QAbstractItemModel)
+	typeComboBox.SetModelColumn(relModel.FieldIndex("description"))
+
+	mapper = qt.NewQDataWidgetMapper2(widget.QObject)
+	mapper.SetModel(model.QAbstractItemModel)
+	relationalDelegate := qt.NewQStyledItemDelegate2(mapper.QObject)
+	mapper.SetItemDelegate(relationalDelegate.QAbstractItemDelegate)
+	mapper.AddMapping(nameEdit.QWidget, model.FieldIndex("name"))
+	mapper.AddMapping(addressEdit.QWidget, model.FieldIndex("address"))
+	mapper.AddMapping(typeComboBox.QWidget, typeIndex)
+
+	previousButton.OnClicked(toPrevious)
+	nextButton.OnClicked(toNext)
+	mapper.OnCurrentIndexChanged(updateButtons)
+
+	layout := qt.NewQGridLayout2()
+	layout.AddWidget2(nameLabel.QWidget, 0, 0)
+	layout.AddWidget2(nameEdit.QWidget, 0, 1)
+	layout.AddWidget2(previousButton.QWidget, 0, 2)
+	layout.AddWidget2(addressLabel.QWidget, 1, 0)
+	layout.AddWidget3(addressEdit.QWidget, 1, 1, 2, 1)
+	layout.AddWidget2(nextButton.QWidget, 1, 2)
+	layout.AddWidget2(typeLabel.QWidget, 3, 0)
+	layout.AddWidget2(typeComboBox.QWidget, 3, 1)
+	widget.SetLayout(layout.QLayout)
+
+	widget.SetWindowTitle("Qt 5 SQL Widget Mapper")
+	mapper.ToFirst()
+
+	widget.Show()
+
+	qt.QApplication_Exec()
+}
+
+func toPrevious() {
+	mapper.ToPrevious()
+}
+
+func toNext() {
+	mapper.ToNext()
+}
+
+func updateButtons(index int) {
+	previousButton.SetEnabled(index > 0)
+	modelIndex := qt.NewQModelIndex()
+	defer modelIndex.Delete()
+	nextButton.SetEnabled(index < model.RowCount(modelIndex)-1)
+}

qt-extras/scintillaedit/gen_ScintillaEdit.go

@@ -15,14 +15,6 @@ import (
 	"unsafe"
 )
 
-type std__pointer_safety int
-
-const (
-	Std__relaxed   std__pointer_safety = 0
-	Std__preferred std__pointer_safety = 1
-	Std__strict    std__pointer_safety = 2
-)
-
 type Scintilla__Internal__Edge int
 
 const (
@@ -1662,12 +1654,6 @@ const (
 	Scintilla__Message__SetBidirectional                          Scintilla__Message = 2709
 )
 
-type std__nullopt_t___Construct int
-
-const (
-	Std__nullopt_t___Token std__nullopt_t___Construct = 0
-)
-
 type Scintilla__Internal__Surface__Ends int
 
 const (

qt/cflags.go

@@ -6,3 +6,7 @@ package qt
 #cgo pkg-config: Qt5Widgets
 */
 import "C"
+
+import (
+	_ "github.com/mappu/miqt/libmiqt"
+)

qt/cflags_windowsqtstatic.go

@@ -12,6 +12,6 @@ package qt
 
 /*
 #cgo windowsqtstatic CXXFLAGS: -DMIQT_WINDOWSQTSTATIC
-#cgo pkg-config: --static QtWidgets
+#cgo pkg-config: --static Qt5Widgets
 */
 import "C"

qt/gen_qglobalstatic.cpp

@@ -0,0 +1,11 @@
+#include <qglobalstatic.h>
+#include "gen_qglobalstatic.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+

qt/gen_qglobalstatic.go

@@ -0,0 +1,18 @@
+package qt
+
+/*
+
+#include "gen_qglobalstatic.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+type QtGlobalStatic__GuardValues int
+
+const (
+	QtGlobalStatic__Destroyed     QtGlobalStatic__GuardValues = -2
+	QtGlobalStatic__Initialized   QtGlobalStatic__GuardValues = -1
+	QtGlobalStatic__Uninitialized QtGlobalStatic__GuardValues = 0
+	QtGlobalStatic__Initializing  QtGlobalStatic__GuardValues = 1
+)

qt/gen_qglobalstatic.h

@@ -0,0 +1,25 @@
+#pragma once
+#ifndef MIQT_QT_GEN_QGLOBALSTATIC_H
+#define MIQT_QT_GEN_QGLOBALSTATIC_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#else
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/gen_qsysinfo.cpp

@@ -0,0 +1,147 @@
+#include <QByteArray>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QSysInfo>
+#include <qsysinfo.h>
+#include "gen_qsysinfo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+int QSysInfo_windowsVersion() {
+	QSysInfo::WinVersion _ret = QSysInfo::windowsVersion();
+	return static_cast<int>(_ret);
+}
+
+int QSysInfo_macVersion() {
+	QSysInfo::MacVersion _ret = QSysInfo::macVersion();
+	return static_cast<int>(_ret);
+}
+
+struct miqt_string QSysInfo_buildCpuArchitecture() {
+	QString _ret = QSysInfo::buildCpuArchitecture();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_currentCpuArchitecture() {
+	QString _ret = QSysInfo::currentCpuArchitecture();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_buildAbi() {
+	QString _ret = QSysInfo::buildAbi();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_kernelType() {
+	QString _ret = QSysInfo::kernelType();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_kernelVersion() {
+	QString _ret = QSysInfo::kernelVersion();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_productType() {
+	QString _ret = QSysInfo::productType();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_productVersion() {
+	QString _ret = QSysInfo::productVersion();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_prettyProductName() {
+	QString _ret = QSysInfo::prettyProductName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_machineHostName() {
+	QString _ret = QSysInfo::machineHostName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_machineUniqueId() {
+	QByteArray _qb = QSysInfo::machineUniqueId();
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_bootUniqueId() {
+	QByteArray _qb = QSysInfo::bootUniqueId();
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+void QSysInfo_delete(QSysInfo* self) {
+	delete self;
+}
+

qt/gen_qsysinfo.go

@@ -0,0 +1,256 @@
+package qt
+
+/*
+
+#include "gen_qsysinfo.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSysInfo__Sizes int
+
+const (
+	QSysInfo__WordSize QSysInfo__Sizes = 64
+)
+
+type QSysInfo__Endian int
+
+const (
+	QSysInfo__BigEndian    QSysInfo__Endian = 0
+	QSysInfo__LittleEndian QSysInfo__Endian = 1
+	QSysInfo__ByteOrder    QSysInfo__Endian = 1
+)
+
+type QSysInfo__WinVersion int
+
+const (
+	QSysInfo__WV_None       QSysInfo__WinVersion = 0
+	QSysInfo__WV_32s        QSysInfo__WinVersion = 1
+	QSysInfo__WV_95         QSysInfo__WinVersion = 2
+	QSysInfo__WV_98         QSysInfo__WinVersion = 3
+	QSysInfo__WV_Me         QSysInfo__WinVersion = 4
+	QSysInfo__WV_DOS_based  QSysInfo__WinVersion = 15
+	QSysInfo__WV_NT         QSysInfo__WinVersion = 16
+	QSysInfo__WV_2000       QSysInfo__WinVersion = 32
+	QSysInfo__WV_XP         QSysInfo__WinVersion = 48
+	QSysInfo__WV_2003       QSysInfo__WinVersion = 64
+	QSysInfo__WV_VISTA      QSysInfo__WinVersion = 128
+	QSysInfo__WV_WINDOWS7   QSysInfo__WinVersion = 144
+	QSysInfo__WV_WINDOWS8   QSysInfo__WinVersion = 160
+	QSysInfo__WV_WINDOWS8_1 QSysInfo__WinVersion = 176
+	QSysInfo__WV_WINDOWS10  QSysInfo__WinVersion = 192
+	QSysInfo__WV_NT_based   QSysInfo__WinVersion = 240
+	QSysInfo__WV_4_0        QSysInfo__WinVersion = 16
+	QSysInfo__WV_5_0        QSysInfo__WinVersion = 32
+	QSysInfo__WV_5_1        QSysInfo__WinVersion = 48
+	QSysInfo__WV_5_2        QSysInfo__WinVersion = 64
+	QSysInfo__WV_6_0        QSysInfo__WinVersion = 128
+	QSysInfo__WV_6_1        QSysInfo__WinVersion = 144
+	QSysInfo__WV_6_2        QSysInfo__WinVersion = 160
+	QSysInfo__WV_6_3        QSysInfo__WinVersion = 176
+	QSysInfo__WV_10_0       QSysInfo__WinVersion = 192
+	QSysInfo__WV_CE         QSysInfo__WinVersion = 256
+	QSysInfo__WV_CENET      QSysInfo__WinVersion = 512
+	QSysInfo__WV_CE_5       QSysInfo__WinVersion = 768
+	QSysInfo__WV_CE_6       QSysInfo__WinVersion = 1024
+	QSysInfo__WV_CE_based   QSysInfo__WinVersion = 3840
+)
+
+type QSysInfo__MacVersion int
+
+const (
+	QSysInfo__MV_None         QSysInfo__MacVersion = 65535
+	QSysInfo__MV_Unknown      QSysInfo__MacVersion = 0
+	QSysInfo__MV_9            QSysInfo__MacVersion = 1
+	QSysInfo__MV_10_0         QSysInfo__MacVersion = 2
+	QSysInfo__MV_10_1         QSysInfo__MacVersion = 3
+	QSysInfo__MV_10_2         QSysInfo__MacVersion = 4
+	QSysInfo__MV_10_3         QSysInfo__MacVersion = 5
+	QSysInfo__MV_10_4         QSysInfo__MacVersion = 6
+	QSysInfo__MV_10_5         QSysInfo__MacVersion = 7
+	QSysInfo__MV_10_6         QSysInfo__MacVersion = 8
+	QSysInfo__MV_10_7         QSysInfo__MacVersion = 9
+	QSysInfo__MV_10_8         QSysInfo__MacVersion = 10
+	QSysInfo__MV_10_9         QSysInfo__MacVersion = 11
+	QSysInfo__MV_10_10        QSysInfo__MacVersion = 12
+	QSysInfo__MV_10_11        QSysInfo__MacVersion = 13
+	QSysInfo__MV_10_12        QSysInfo__MacVersion = 14
+	QSysInfo__MV_CHEETAH      QSysInfo__MacVersion = 2
+	QSysInfo__MV_PUMA         QSysInfo__MacVersion = 3
+	QSysInfo__MV_JAGUAR       QSysInfo__MacVersion = 4
+	QSysInfo__MV_PANTHER      QSysInfo__MacVersion = 5
+	QSysInfo__MV_TIGER        QSysInfo__MacVersion = 6
+	QSysInfo__MV_LEOPARD      QSysInfo__MacVersion = 7
+	QSysInfo__MV_SNOWLEOPARD  QSysInfo__MacVersion = 8
+	QSysInfo__MV_LION         QSysInfo__MacVersion = 9
+	QSysInfo__MV_MOUNTAINLION QSysInfo__MacVersion = 10
+	QSysInfo__MV_MAVERICKS    QSysInfo__MacVersion = 11
+	QSysInfo__MV_YOSEMITE     QSysInfo__MacVersion = 12
+	QSysInfo__MV_ELCAPITAN    QSysInfo__MacVersion = 13
+	QSysInfo__MV_SIERRA       QSysInfo__MacVersion = 14
+	QSysInfo__MV_IOS          QSysInfo__MacVersion = 256
+	QSysInfo__MV_IOS_4_3      QSysInfo__MacVersion = 323
+	QSysInfo__MV_IOS_5_0      QSysInfo__MacVersion = 336
+	QSysInfo__MV_IOS_5_1      QSysInfo__MacVersion = 337
+	QSysInfo__MV_IOS_6_0      QSysInfo__MacVersion = 352
+	QSysInfo__MV_IOS_6_1      QSysInfo__MacVersion = 353
+	QSysInfo__MV_IOS_7_0      QSysInfo__MacVersion = 368
+	QSysInfo__MV_IOS_7_1      QSysInfo__MacVersion = 369
+	QSysInfo__MV_IOS_8_0      QSysInfo__MacVersion = 384
+	QSysInfo__MV_IOS_8_1      QSysInfo__MacVersion = 385
+	QSysInfo__MV_IOS_8_2      QSysInfo__MacVersion = 386
+	QSysInfo__MV_IOS_8_3      QSysInfo__MacVersion = 387
+	QSysInfo__MV_IOS_8_4      QSysInfo__MacVersion = 388
+	QSysInfo__MV_IOS_9_0      QSysInfo__MacVersion = 400
+	QSysInfo__MV_IOS_9_1      QSysInfo__MacVersion = 401
+	QSysInfo__MV_IOS_9_2      QSysInfo__MacVersion = 402
+	QSysInfo__MV_IOS_9_3      QSysInfo__MacVersion = 403
+	QSysInfo__MV_IOS_10_0     QSysInfo__MacVersion = 416
+	QSysInfo__MV_TVOS         QSysInfo__MacVersion = 512
+	QSysInfo__MV_TVOS_9_0     QSysInfo__MacVersion = 656
+	QSysInfo__MV_TVOS_9_1     QSysInfo__MacVersion = 657
+	QSysInfo__MV_TVOS_9_2     QSysInfo__MacVersion = 658
+	QSysInfo__MV_TVOS_10_0    QSysInfo__MacVersion = 672
+	QSysInfo__MV_WATCHOS      QSysInfo__MacVersion = 1024
+	QSysInfo__MV_WATCHOS_2_0  QSysInfo__MacVersion = 1056
+	QSysInfo__MV_WATCHOS_2_1  QSysInfo__MacVersion = 1057
+	QSysInfo__MV_WATCHOS_2_2  QSysInfo__MacVersion = 1058
+	QSysInfo__MV_WATCHOS_3_0  QSysInfo__MacVersion = 1072
+)
+
+type QSysInfo struct {
+	h *C.QSysInfo
+}
+
+func (this *QSysInfo) cPointer() *C.QSysInfo {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSysInfo) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSysInfo constructs the type using only CGO pointers.
+func newQSysInfo(h *C.QSysInfo) *QSysInfo {
+	if h == nil {
+		return nil
+	}
+
+	return &QSysInfo{h: h}
+}
+
+// UnsafeNewQSysInfo constructs the type using only unsafe pointers.
+func UnsafeNewQSysInfo(h unsafe.Pointer) *QSysInfo {
+	return newQSysInfo((*C.QSysInfo)(h))
+}
+
+func QSysInfo_WindowsVersion() QSysInfo__WinVersion {
+	return (QSysInfo__WinVersion)(C.QSysInfo_windowsVersion())
+}
+
+func QSysInfo_MacVersion() QSysInfo__MacVersion {
+	return (QSysInfo__MacVersion)(C.QSysInfo_macVersion())
+}
+
+func QSysInfo_BuildCpuArchitecture() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_buildCpuArchitecture()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_CurrentCpuArchitecture() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_currentCpuArchitecture()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_BuildAbi() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_buildAbi()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_KernelType() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_kernelType()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_KernelVersion() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_kernelVersion()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_ProductType() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_productType()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_ProductVersion() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_productVersion()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_PrettyProductName() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_prettyProductName()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_MachineHostName() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_machineHostName()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_MachineUniqueId() []byte {
+	var _bytearray C.struct_miqt_string = C.QSysInfo_machineUniqueId()
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+func QSysInfo_BootUniqueId() []byte {
+	var _bytearray C.struct_miqt_string = C.QSysInfo_bootUniqueId()
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+// Delete this object from C++ memory.
+func (this *QSysInfo) Delete() {
+	C.QSysInfo_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSysInfo) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSysInfo) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/gen_qsysinfo.h

@@ -0,0 +1,43 @@
+#pragma once
+#ifndef MIQT_QT_GEN_QSYSINFO_H
+#define MIQT_QT_GEN_QSYSINFO_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSysInfo;
+#else
+typedef struct QSysInfo QSysInfo;
+#endif
+
+int QSysInfo_windowsVersion();
+int QSysInfo_macVersion();
+struct miqt_string QSysInfo_buildCpuArchitecture();
+struct miqt_string QSysInfo_currentCpuArchitecture();
+struct miqt_string QSysInfo_buildAbi();
+struct miqt_string QSysInfo_kernelType();
+struct miqt_string QSysInfo_kernelVersion();
+struct miqt_string QSysInfo_productType();
+struct miqt_string QSysInfo_productVersion();
+struct miqt_string QSysInfo_prettyProductName();
+struct miqt_string QSysInfo_machineHostName();
+struct miqt_string QSysInfo_machineUniqueId();
+struct miqt_string QSysInfo_bootUniqueId();
+
+void QSysInfo_delete(QSysInfo* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/cflags.go

@@ -0,0 +1,6 @@
+package sql
+
+/*
+#cgo pkg-config: Qt5Sql
+*/
+import "C"

qt/sql/gen_qsqldatabase.cpp

@@ -0,0 +1,387 @@
+#include <QList>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QSqlDriverCreatorBase>
+#include <QSqlError>
+#include <QSqlIndex>
+#include <QSqlQuery>
+#include <QSqlRecord>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qsqldatabase.h>
+#include "gen_qsqldatabase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlDriver* QSqlDriverCreatorBase_createObject(const QSqlDriverCreatorBase* self) {
+	return self->createObject();
+}
+
+void QSqlDriverCreatorBase_operatorAssign(QSqlDriverCreatorBase* self, QSqlDriverCreatorBase* param1) {
+	self->operator=(*param1);
+}
+
+void QSqlDriverCreatorBase_delete(QSqlDriverCreatorBase* self) {
+	delete self;
+}
+
+QSqlDatabase* QSqlDatabase_new() {
+	return new (std::nothrow) QSqlDatabase();
+}
+
+QSqlDatabase* QSqlDatabase_new2(QSqlDatabase* other) {
+	return new (std::nothrow) QSqlDatabase(*other);
+}
+
+void QSqlDatabase_operatorAssign(QSqlDatabase* self, QSqlDatabase* other) {
+	self->operator=(*other);
+}
+
+bool QSqlDatabase_open(QSqlDatabase* self) {
+	return self->open();
+}
+
+bool QSqlDatabase_open2(QSqlDatabase* self, struct miqt_string user, struct miqt_string password) {
+	QString user_QString = QString::fromUtf8(user.data, user.len);
+	QString password_QString = QString::fromUtf8(password.data, password.len);
+	return self->open(user_QString, password_QString);
+}
+
+void QSqlDatabase_close(QSqlDatabase* self) {
+	self->close();
+}
+
+bool QSqlDatabase_isOpen(const QSqlDatabase* self) {
+	return self->isOpen();
+}
+
+bool QSqlDatabase_isOpenError(const QSqlDatabase* self) {
+	return self->isOpenError();
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tables(const QSqlDatabase* self) {
+	QStringList _ret = self->tables();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+QSqlIndex* QSqlDatabase_primaryIndex(const QSqlDatabase* self, struct miqt_string tablename) {
+	QString tablename_QString = QString::fromUtf8(tablename.data, tablename.len);
+	return new QSqlIndex(self->primaryIndex(tablename_QString));
+}
+
+QSqlRecord* QSqlDatabase_record(const QSqlDatabase* self, struct miqt_string tablename) {
+	QString tablename_QString = QString::fromUtf8(tablename.data, tablename.len);
+	return new QSqlRecord(self->record(tablename_QString));
+}
+
+QSqlQuery* QSqlDatabase_exec(const QSqlDatabase* self) {
+	return new QSqlQuery(self->exec());
+}
+
+QSqlError* QSqlDatabase_lastError(const QSqlDatabase* self) {
+	return new QSqlError(self->lastError());
+}
+
+bool QSqlDatabase_isValid(const QSqlDatabase* self) {
+	return self->isValid();
+}
+
+bool QSqlDatabase_transaction(QSqlDatabase* self) {
+	return self->transaction();
+}
+
+bool QSqlDatabase_commit(QSqlDatabase* self) {
+	return self->commit();
+}
+
+bool QSqlDatabase_rollback(QSqlDatabase* self) {
+	return self->rollback();
+}
+
+void QSqlDatabase_setDatabaseName(QSqlDatabase* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setDatabaseName(name_QString);
+}
+
+void QSqlDatabase_setUserName(QSqlDatabase* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setUserName(name_QString);
+}
+
+void QSqlDatabase_setPassword(QSqlDatabase* self, struct miqt_string password) {
+	QString password_QString = QString::fromUtf8(password.data, password.len);
+	self->setPassword(password_QString);
+}
+
+void QSqlDatabase_setHostName(QSqlDatabase* self, struct miqt_string host) {
+	QString host_QString = QString::fromUtf8(host.data, host.len);
+	self->setHostName(host_QString);
+}
+
+void QSqlDatabase_setPort(QSqlDatabase* self, int p) {
+	self->setPort(static_cast<int>(p));
+}
+
+void QSqlDatabase_setConnectOptions(QSqlDatabase* self) {
+	self->setConnectOptions();
+}
+
+struct miqt_string QSqlDatabase_databaseName(const QSqlDatabase* self) {
+	QString _ret = self->databaseName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_userName(const QSqlDatabase* self) {
+	QString _ret = self->userName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_password(const QSqlDatabase* self) {
+	QString _ret = self->password();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_hostName(const QSqlDatabase* self) {
+	QString _ret = self->hostName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_driverName(const QSqlDatabase* self) {
+	QString _ret = self->driverName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QSqlDatabase_port(const QSqlDatabase* self) {
+	return self->port();
+}
+
+struct miqt_string QSqlDatabase_connectOptions(const QSqlDatabase* self) {
+	QString _ret = self->connectOptions();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_connectionName(const QSqlDatabase* self) {
+	QString _ret = self->connectionName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlDatabase_setNumericalPrecisionPolicy(QSqlDatabase* self, int precisionPolicy) {
+	self->setNumericalPrecisionPolicy(static_cast<QSql::NumericalPrecisionPolicy>(precisionPolicy));
+}
+
+int QSqlDatabase_numericalPrecisionPolicy(const QSqlDatabase* self) {
+	QSql::NumericalPrecisionPolicy _ret = self->numericalPrecisionPolicy();
+	return static_cast<int>(_ret);
+}
+
+QSqlDriver* QSqlDatabase_driver(const QSqlDatabase* self) {
+	return self->driver();
+}
+
+QSqlDatabase* QSqlDatabase_addDatabase(struct miqt_string type) {
+	QString type_QString = QString::fromUtf8(type.data, type.len);
+	return new QSqlDatabase(QSqlDatabase::addDatabase(type_QString));
+}
+
+QSqlDatabase* QSqlDatabase_addDatabaseWithDriver(QSqlDriver* driver) {
+	return new QSqlDatabase(QSqlDatabase::addDatabase(driver));
+}
+
+QSqlDatabase* QSqlDatabase_cloneDatabase(QSqlDatabase* other, struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::cloneDatabase(*other, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_cloneDatabase2(struct miqt_string other, struct miqt_string connectionName) {
+	QString other_QString = QString::fromUtf8(other.data, other.len);
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::cloneDatabase(other_QString, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_database() {
+	return new QSqlDatabase(QSqlDatabase::database());
+}
+
+void QSqlDatabase_removeDatabase(struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	QSqlDatabase::removeDatabase(connectionName_QString);
+}
+
+bool QSqlDatabase_contains() {
+	return QSqlDatabase::contains();
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_drivers() {
+	QStringList _ret = QSqlDatabase::drivers();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_connectionNames() {
+	QStringList _ret = QSqlDatabase::connectionNames();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+void QSqlDatabase_registerSqlDriver(struct miqt_string name, QSqlDriverCreatorBase* creator) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	QSqlDatabase::registerSqlDriver(name_QString, creator);
+}
+
+bool QSqlDatabase_isDriverAvailable(struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return QSqlDatabase::isDriverAvailable(name_QString);
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tablesWithType(const QSqlDatabase* self, int type) {
+	QStringList _ret = self->tables(static_cast<QSql::TableType>(type));
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+QSqlQuery* QSqlDatabase_execWithQuery(const QSqlDatabase* self, struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return new QSqlQuery(self->exec(query_QString));
+}
+
+void QSqlDatabase_setConnectOptionsWithOptions(QSqlDatabase* self, struct miqt_string options) {
+	QString options_QString = QString::fromUtf8(options.data, options.len);
+	self->setConnectOptions(options_QString);
+}
+
+QSqlDatabase* QSqlDatabase_addDatabase2(struct miqt_string type, struct miqt_string connectionName) {
+	QString type_QString = QString::fromUtf8(type.data, type.len);
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::addDatabase(type_QString, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_addDatabase3(QSqlDriver* driver, struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::addDatabase(driver, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_databaseWithConnectionName(struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::database(connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_database2(struct miqt_string connectionName, bool open) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::database(connectionName_QString, open));
+}
+
+bool QSqlDatabase_containsWithConnectionName(struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return QSqlDatabase::contains(connectionName_QString);
+}
+
+void QSqlDatabase_delete(QSqlDatabase* self) {
+	delete self;
+}
+

qt/sql/gen_qsqldatabase.go

@@ -0,0 +1,507 @@
+package sql
+
+/*
+
+#include "gen_qsqldatabase.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSqlDriverCreatorBase struct {
+	h *C.QSqlDriverCreatorBase
+}
+
+func (this *QSqlDriverCreatorBase) cPointer() *C.QSqlDriverCreatorBase {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlDriverCreatorBase) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlDriverCreatorBase constructs the type using only CGO pointers.
+func newQSqlDriverCreatorBase(h *C.QSqlDriverCreatorBase) *QSqlDriverCreatorBase {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlDriverCreatorBase{h: h}
+}
+
+// UnsafeNewQSqlDriverCreatorBase constructs the type using only unsafe pointers.
+func UnsafeNewQSqlDriverCreatorBase(h unsafe.Pointer) *QSqlDriverCreatorBase {
+	return newQSqlDriverCreatorBase((*C.QSqlDriverCreatorBase)(h))
+}
+
+func (this *QSqlDriverCreatorBase) CreateObject() *QSqlDriver {
+	return newQSqlDriver(C.QSqlDriverCreatorBase_createObject(this.h))
+}
+
+func (this *QSqlDriverCreatorBase) OperatorAssign(param1 *QSqlDriverCreatorBase) {
+	C.QSqlDriverCreatorBase_operatorAssign(this.h, param1.cPointer())
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlDriverCreatorBase) Delete() {
+	C.QSqlDriverCreatorBase_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlDriverCreatorBase) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlDriverCreatorBase) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QSqlDatabase struct {
+	h *C.QSqlDatabase
+}
+
+func (this *QSqlDatabase) cPointer() *C.QSqlDatabase {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlDatabase) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlDatabase constructs the type using only CGO pointers.
+func newQSqlDatabase(h *C.QSqlDatabase) *QSqlDatabase {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlDatabase{h: h}
+}
+
+// UnsafeNewQSqlDatabase constructs the type using only unsafe pointers.
+func UnsafeNewQSqlDatabase(h unsafe.Pointer) *QSqlDatabase {
+	return newQSqlDatabase((*C.QSqlDatabase)(h))
+}
+
+// NewQSqlDatabase constructs a new QSqlDatabase object.
+func NewQSqlDatabase() *QSqlDatabase {
+
+	return newQSqlDatabase(C.QSqlDatabase_new())
+}
+
+// NewQSqlDatabase2 constructs a new QSqlDatabase object.
+func NewQSqlDatabase2(other *QSqlDatabase) *QSqlDatabase {
+
+	return newQSqlDatabase(C.QSqlDatabase_new2(other.cPointer()))
+}
+
+func (this *QSqlDatabase) OperatorAssign(other *QSqlDatabase) {
+	C.QSqlDatabase_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlDatabase) Open() bool {
+	return (bool)(C.QSqlDatabase_open(this.h))
+}
+
+func (this *QSqlDatabase) Open2(user string, password string) bool {
+	user_ms := C.struct_miqt_string{}
+	user_ms.data = C.CString(user)
+	user_ms.len = C.size_t(len(user))
+	defer C.free(unsafe.Pointer(user_ms.data))
+	password_ms := C.struct_miqt_string{}
+	password_ms.data = C.CString(password)
+	password_ms.len = C.size_t(len(password))
+	defer C.free(unsafe.Pointer(password_ms.data))
+	return (bool)(C.QSqlDatabase_open2(this.h, user_ms, password_ms))
+}
+
+func (this *QSqlDatabase) Close() {
+	C.QSqlDatabase_close(this.h)
+}
+
+func (this *QSqlDatabase) IsOpen() bool {
+	return (bool)(C.QSqlDatabase_isOpen(this.h))
+}
+
+func (this *QSqlDatabase) IsOpenError() bool {
+	return (bool)(C.QSqlDatabase_isOpenError(this.h))
+}
+
+func (this *QSqlDatabase) Tables() []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_tables(this.h)
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func (this *QSqlDatabase) PrimaryIndex(tablename string) *QSqlIndex {
+	tablename_ms := C.struct_miqt_string{}
+	tablename_ms.data = C.CString(tablename)
+	tablename_ms.len = C.size_t(len(tablename))
+	defer C.free(unsafe.Pointer(tablename_ms.data))
+	_goptr := newQSqlIndex(C.QSqlDatabase_primaryIndex(this.h, tablename_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) Record(tablename string) *QSqlRecord {
+	tablename_ms := C.struct_miqt_string{}
+	tablename_ms.data = C.CString(tablename)
+	tablename_ms.len = C.size_t(len(tablename))
+	defer C.free(unsafe.Pointer(tablename_ms.data))
+	_goptr := newQSqlRecord(C.QSqlDatabase_record(this.h, tablename_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) Exec() *QSqlQuery {
+	_goptr := newQSqlQuery(C.QSqlDatabase_exec(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) LastError() *QSqlError {
+	_goptr := newQSqlError(C.QSqlDatabase_lastError(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) IsValid() bool {
+	return (bool)(C.QSqlDatabase_isValid(this.h))
+}
+
+func (this *QSqlDatabase) Transaction() bool {
+	return (bool)(C.QSqlDatabase_transaction(this.h))
+}
+
+func (this *QSqlDatabase) Commit() bool {
+	return (bool)(C.QSqlDatabase_commit(this.h))
+}
+
+func (this *QSqlDatabase) Rollback() bool {
+	return (bool)(C.QSqlDatabase_rollback(this.h))
+}
+
+func (this *QSqlDatabase) SetDatabaseName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlDatabase_setDatabaseName(this.h, name_ms)
+}
+
+func (this *QSqlDatabase) SetUserName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlDatabase_setUserName(this.h, name_ms)
+}
+
+func (this *QSqlDatabase) SetPassword(password string) {
+	password_ms := C.struct_miqt_string{}
+	password_ms.data = C.CString(password)
+	password_ms.len = C.size_t(len(password))
+	defer C.free(unsafe.Pointer(password_ms.data))
+	C.QSqlDatabase_setPassword(this.h, password_ms)
+}
+
+func (this *QSqlDatabase) SetHostName(host string) {
+	host_ms := C.struct_miqt_string{}
+	host_ms.data = C.CString(host)
+	host_ms.len = C.size_t(len(host))
+	defer C.free(unsafe.Pointer(host_ms.data))
+	C.QSqlDatabase_setHostName(this.h, host_ms)
+}
+
+func (this *QSqlDatabase) SetPort(p int) {
+	C.QSqlDatabase_setPort(this.h, (C.int)(p))
+}
+
+func (this *QSqlDatabase) SetConnectOptions() {
+	C.QSqlDatabase_setConnectOptions(this.h)
+}
+
+func (this *QSqlDatabase) DatabaseName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_databaseName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) UserName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_userName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) Password() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_password(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) HostName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_hostName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) DriverName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_driverName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) Port() int {
+	return (int)(C.QSqlDatabase_port(this.h))
+}
+
+func (this *QSqlDatabase) ConnectOptions() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_connectOptions(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) ConnectionName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_connectionName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) SetNumericalPrecisionPolicy(precisionPolicy QSql__NumericalPrecisionPolicy) {
+	C.QSqlDatabase_setNumericalPrecisionPolicy(this.h, (C.int)(precisionPolicy))
+}
+
+func (this *QSqlDatabase) NumericalPrecisionPolicy() QSql__NumericalPrecisionPolicy {
+	return (QSql__NumericalPrecisionPolicy)(C.QSqlDatabase_numericalPrecisionPolicy(this.h))
+}
+
+func (this *QSqlDatabase) Driver() *QSqlDriver {
+	return newQSqlDriver(C.QSqlDatabase_driver(this.h))
+}
+
+func QSqlDatabase_AddDatabase(typeVal string) *QSqlDatabase {
+	typeVal_ms := C.struct_miqt_string{}
+	typeVal_ms.data = C.CString(typeVal)
+	typeVal_ms.len = C.size_t(len(typeVal))
+	defer C.free(unsafe.Pointer(typeVal_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabase(typeVal_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_AddDatabaseWithDriver(driver *QSqlDriver) *QSqlDatabase {
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabaseWithDriver(driver.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_CloneDatabase(other *QSqlDatabase, connectionName string) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_cloneDatabase(other.cPointer(), connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_CloneDatabase2(other string, connectionName string) *QSqlDatabase {
+	other_ms := C.struct_miqt_string{}
+	other_ms.data = C.CString(other)
+	other_ms.len = C.size_t(len(other))
+	defer C.free(unsafe.Pointer(other_ms.data))
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_cloneDatabase2(other_ms, connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_Database() *QSqlDatabase {
+	_goptr := newQSqlDatabase(C.QSqlDatabase_database())
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_RemoveDatabase(connectionName string) {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	C.QSqlDatabase_removeDatabase(connectionName_ms)
+}
+
+func QSqlDatabase_Contains() bool {
+	return (bool)(C.QSqlDatabase_contains())
+}
+
+func QSqlDatabase_Drivers() []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_drivers()
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func QSqlDatabase_ConnectionNames() []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_connectionNames()
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func QSqlDatabase_RegisterSqlDriver(name string, creator *QSqlDriverCreatorBase) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlDatabase_registerSqlDriver(name_ms, creator.cPointer())
+}
+
+func QSqlDatabase_IsDriverAvailable(name string) bool {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (bool)(C.QSqlDatabase_isDriverAvailable(name_ms))
+}
+
+func (this *QSqlDatabase) TablesWithType(typeVal QSql__TableType) []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_tablesWithType(this.h, (C.int)(typeVal))
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func (this *QSqlDatabase) ExecWithQuery(query string) *QSqlQuery {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+	_goptr := newQSqlQuery(C.QSqlDatabase_execWithQuery(this.h, query_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) SetConnectOptionsWithOptions(options string) {
+	options_ms := C.struct_miqt_string{}
+	options_ms.data = C.CString(options)
+	options_ms.len = C.size_t(len(options))
+	defer C.free(unsafe.Pointer(options_ms.data))
+	C.QSqlDatabase_setConnectOptionsWithOptions(this.h, options_ms)
+}
+
+func QSqlDatabase_AddDatabase2(typeVal string, connectionName string) *QSqlDatabase {
+	typeVal_ms := C.struct_miqt_string{}
+	typeVal_ms.data = C.CString(typeVal)
+	typeVal_ms.len = C.size_t(len(typeVal))
+	defer C.free(unsafe.Pointer(typeVal_ms.data))
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabase2(typeVal_ms, connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_AddDatabase3(driver *QSqlDriver, connectionName string) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabase3(driver.cPointer(), connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_DatabaseWithConnectionName(connectionName string) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_databaseWithConnectionName(connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_Database2(connectionName string, open bool) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_database2(connectionName_ms, (C.bool)(open)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_ContainsWithConnectionName(connectionName string) bool {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	return (bool)(C.QSqlDatabase_containsWithConnectionName(connectionName_ms))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlDatabase) Delete() {
+	C.QSqlDatabase_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlDatabase) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlDatabase) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqldatabase.h

@@ -0,0 +1,100 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLDATABASE_H
+#define MIQT_QT_SQL_GEN_QSQLDATABASE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlDatabase;
+class QSqlDriver;
+class QSqlDriverCreatorBase;
+class QSqlError;
+class QSqlIndex;
+class QSqlQuery;
+class QSqlRecord;
+#else
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlDriverCreatorBase QSqlDriverCreatorBase;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlRecord QSqlRecord;
+#endif
+
+QSqlDriver* QSqlDriverCreatorBase_createObject(const QSqlDriverCreatorBase* self);
+void QSqlDriverCreatorBase_operatorAssign(QSqlDriverCreatorBase* self, QSqlDriverCreatorBase* param1);
+
+void QSqlDriverCreatorBase_delete(QSqlDriverCreatorBase* self);
+
+QSqlDatabase* QSqlDatabase_new();
+QSqlDatabase* QSqlDatabase_new2(QSqlDatabase* other);
+void QSqlDatabase_operatorAssign(QSqlDatabase* self, QSqlDatabase* other);
+bool QSqlDatabase_open(QSqlDatabase* self);
+bool QSqlDatabase_open2(QSqlDatabase* self, struct miqt_string user, struct miqt_string password);
+void QSqlDatabase_close(QSqlDatabase* self);
+bool QSqlDatabase_isOpen(const QSqlDatabase* self);
+bool QSqlDatabase_isOpenError(const QSqlDatabase* self);
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tables(const QSqlDatabase* self);
+QSqlIndex* QSqlDatabase_primaryIndex(const QSqlDatabase* self, struct miqt_string tablename);
+QSqlRecord* QSqlDatabase_record(const QSqlDatabase* self, struct miqt_string tablename);
+QSqlQuery* QSqlDatabase_exec(const QSqlDatabase* self);
+QSqlError* QSqlDatabase_lastError(const QSqlDatabase* self);
+bool QSqlDatabase_isValid(const QSqlDatabase* self);
+bool QSqlDatabase_transaction(QSqlDatabase* self);
+bool QSqlDatabase_commit(QSqlDatabase* self);
+bool QSqlDatabase_rollback(QSqlDatabase* self);
+void QSqlDatabase_setDatabaseName(QSqlDatabase* self, struct miqt_string name);
+void QSqlDatabase_setUserName(QSqlDatabase* self, struct miqt_string name);
+void QSqlDatabase_setPassword(QSqlDatabase* self, struct miqt_string password);
+void QSqlDatabase_setHostName(QSqlDatabase* self, struct miqt_string host);
+void QSqlDatabase_setPort(QSqlDatabase* self, int p);
+void QSqlDatabase_setConnectOptions(QSqlDatabase* self);
+struct miqt_string QSqlDatabase_databaseName(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_userName(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_password(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_hostName(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_driverName(const QSqlDatabase* self);
+int QSqlDatabase_port(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_connectOptions(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_connectionName(const QSqlDatabase* self);
+void QSqlDatabase_setNumericalPrecisionPolicy(QSqlDatabase* self, int precisionPolicy);
+int QSqlDatabase_numericalPrecisionPolicy(const QSqlDatabase* self);
+QSqlDriver* QSqlDatabase_driver(const QSqlDatabase* self);
+QSqlDatabase* QSqlDatabase_addDatabase(struct miqt_string type);
+QSqlDatabase* QSqlDatabase_addDatabaseWithDriver(QSqlDriver* driver);
+QSqlDatabase* QSqlDatabase_cloneDatabase(QSqlDatabase* other, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_cloneDatabase2(struct miqt_string other, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_database();
+void QSqlDatabase_removeDatabase(struct miqt_string connectionName);
+bool QSqlDatabase_contains();
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_drivers();
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_connectionNames();
+void QSqlDatabase_registerSqlDriver(struct miqt_string name, QSqlDriverCreatorBase* creator);
+bool QSqlDatabase_isDriverAvailable(struct miqt_string name);
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tablesWithType(const QSqlDatabase* self, int type);
+QSqlQuery* QSqlDatabase_execWithQuery(const QSqlDatabase* self, struct miqt_string query);
+void QSqlDatabase_setConnectOptionsWithOptions(QSqlDatabase* self, struct miqt_string options);
+QSqlDatabase* QSqlDatabase_addDatabase2(struct miqt_string type, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_addDatabase3(QSqlDriver* driver, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_databaseWithConnectionName(struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_database2(struct miqt_string connectionName, bool open);
+bool QSqlDatabase_containsWithConnectionName(struct miqt_string connectionName);
+
+void QSqlDatabase_delete(QSqlDatabase* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqldriver.h

@@ -0,0 +1,166 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLDRIVER_H
+#define MIQT_QT_SQL_GEN_QSQLDRIVER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QSqlDriver;
+class QSqlError;
+class QSqlField;
+class QSqlIndex;
+class QSqlRecord;
+class QSqlResult;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlField QSqlField;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QSqlResult QSqlResult;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlDriver* QSqlDriver_new();
+QSqlDriver* QSqlDriver_new2(QObject* parent);
+void QSqlDriver_virtbase(QSqlDriver* src, QObject** outptr_QObject);
+QMetaObject* QSqlDriver_metaObject(const QSqlDriver* self);
+void* QSqlDriver_metacast(QSqlDriver* self, const char* param1);
+struct miqt_string QSqlDriver_tr(const char* s);
+struct miqt_string QSqlDriver_trUtf8(const char* s);
+bool QSqlDriver_isOpen(const QSqlDriver* self);
+bool QSqlDriver_isOpenError(const QSqlDriver* self);
+bool QSqlDriver_beginTransaction(QSqlDriver* self);
+bool QSqlDriver_commitTransaction(QSqlDriver* self);
+bool QSqlDriver_rollbackTransaction(QSqlDriver* self);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_tables(const QSqlDriver* self, int tableType);
+QSqlIndex* QSqlDriver_primaryIndex(const QSqlDriver* self, struct miqt_string tableName);
+QSqlRecord* QSqlDriver_record(const QSqlDriver* self, struct miqt_string tableName);
+struct miqt_string QSqlDriver_formatValue(const QSqlDriver* self, QSqlField* field, bool trimStrings);
+struct miqt_string QSqlDriver_escapeIdentifier(const QSqlDriver* self, struct miqt_string identifier, int type);
+struct miqt_string QSqlDriver_sqlStatement(const QSqlDriver* self, int type, struct miqt_string tableName, QSqlRecord* rec, bool preparedStatement);
+QSqlError* QSqlDriver_lastError(const QSqlDriver* self);
+QVariant* QSqlDriver_handle(const QSqlDriver* self);
+bool QSqlDriver_hasFeature(const QSqlDriver* self, int f);
+void QSqlDriver_close(QSqlDriver* self);
+QSqlResult* QSqlDriver_createResult(const QSqlDriver* self);
+bool QSqlDriver_open(QSqlDriver* self, struct miqt_string db, struct miqt_string user, struct miqt_string password, struct miqt_string host, int port, struct miqt_string connOpts);
+bool QSqlDriver_subscribeToNotification(QSqlDriver* self, struct miqt_string name);
+bool QSqlDriver_unsubscribeFromNotification(QSqlDriver* self, struct miqt_string name);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_subscribedToNotifications(const QSqlDriver* self);
+bool QSqlDriver_isIdentifierEscaped(const QSqlDriver* self, struct miqt_string identifier, int type);
+struct miqt_string QSqlDriver_stripDelimiters(const QSqlDriver* self, struct miqt_string identifier, int type);
+void QSqlDriver_setNumericalPrecisionPolicy(QSqlDriver* self, int precisionPolicy);
+int QSqlDriver_numericalPrecisionPolicy(const QSqlDriver* self);
+int QSqlDriver_dbmsType(const QSqlDriver* self);
+bool QSqlDriver_cancelQuery(QSqlDriver* self);
+void QSqlDriver_notification(QSqlDriver* self, struct miqt_string name);
+void QSqlDriver_connect_notification(QSqlDriver* self, intptr_t slot);
+void QSqlDriver_notification2(QSqlDriver* self, struct miqt_string name, int source, QVariant* payload);
+void QSqlDriver_connect_notification2(QSqlDriver* self, intptr_t slot);
+void QSqlDriver_setOpen(QSqlDriver* self, bool o);
+void QSqlDriver_setOpenError(QSqlDriver* self, bool e);
+void QSqlDriver_setLastError(QSqlDriver* self, QSqlError* e);
+struct miqt_string QSqlDriver_tr2(const char* s, const char* c);
+struct miqt_string QSqlDriver_tr3(const char* s, const char* c, int n);
+struct miqt_string QSqlDriver_trUtf82(const char* s, const char* c);
+struct miqt_string QSqlDriver_trUtf83(const char* s, const char* c, int n);
+
+bool QSqlDriver_override_virtual_isOpen(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_isOpen(const void* self);
+bool QSqlDriver_override_virtual_beginTransaction(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_beginTransaction(void* self);
+bool QSqlDriver_override_virtual_commitTransaction(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_commitTransaction(void* self);
+bool QSqlDriver_override_virtual_rollbackTransaction(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_rollbackTransaction(void* self);
+bool QSqlDriver_override_virtual_tables(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_virtualbase_tables(const void* self, int tableType);
+bool QSqlDriver_override_virtual_primaryIndex(void* self, intptr_t slot);
+QSqlIndex* QSqlDriver_virtualbase_primaryIndex(const void* self, struct miqt_string tableName);
+bool QSqlDriver_override_virtual_record(void* self, intptr_t slot);
+QSqlRecord* QSqlDriver_virtualbase_record(const void* self, struct miqt_string tableName);
+bool QSqlDriver_override_virtual_formatValue(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_formatValue(const void* self, QSqlField* field, bool trimStrings);
+bool QSqlDriver_override_virtual_escapeIdentifier(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_escapeIdentifier(const void* self, struct miqt_string identifier, int type);
+bool QSqlDriver_override_virtual_sqlStatement(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_sqlStatement(const void* self, int type, struct miqt_string tableName, QSqlRecord* rec, bool preparedStatement);
+bool QSqlDriver_override_virtual_handle(void* self, intptr_t slot);
+QVariant* QSqlDriver_virtualbase_handle(const void* self);
+bool QSqlDriver_override_virtual_hasFeature(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_hasFeature(const void* self, int f);
+bool QSqlDriver_override_virtual_close(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_close(void* self);
+bool QSqlDriver_override_virtual_createResult(void* self, intptr_t slot);
+QSqlResult* QSqlDriver_virtualbase_createResult(const void* self);
+bool QSqlDriver_override_virtual_open(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_open(void* self, struct miqt_string db, struct miqt_string user, struct miqt_string password, struct miqt_string host, int port, struct miqt_string connOpts);
+bool QSqlDriver_override_virtual_subscribeToNotification(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_subscribeToNotification(void* self, struct miqt_string name);
+bool QSqlDriver_override_virtual_unsubscribeFromNotification(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_unsubscribeFromNotification(void* self, struct miqt_string name);
+bool QSqlDriver_override_virtual_subscribedToNotifications(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_virtualbase_subscribedToNotifications(const void* self);
+bool QSqlDriver_override_virtual_isIdentifierEscaped(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_isIdentifierEscaped(const void* self, struct miqt_string identifier, int type);
+bool QSqlDriver_override_virtual_stripDelimiters(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_stripDelimiters(const void* self, struct miqt_string identifier, int type);
+bool QSqlDriver_override_virtual_cancelQuery(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_cancelQuery(void* self);
+bool QSqlDriver_override_virtual_setOpen(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_setOpen(void* self, bool o);
+bool QSqlDriver_override_virtual_setOpenError(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_setOpenError(void* self, bool e);
+bool QSqlDriver_override_virtual_setLastError(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_setLastError(void* self, QSqlError* e);
+bool QSqlDriver_override_virtual_event(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_event(void* self, QEvent* event);
+bool QSqlDriver_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlDriver_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlDriver_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlDriver_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlDriver_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlDriver_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QSqlDriver_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriver_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriver_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlDriver_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlDriver_delete(QSqlDriver* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqldriverplugin.cpp

@@ -0,0 +1,435 @@
+#include <QChildEvent>
+#include <QEvent>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QSqlDriver>
+#include <QSqlDriverPlugin>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTimerEvent>
+#include <qsqldriverplugin.h>
+#include "gen_qsqldriverplugin.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+QSqlDriver* miqt_exec_callback_QSqlDriverPlugin_create(QSqlDriverPlugin*, intptr_t, struct miqt_string);
+bool miqt_exec_callback_QSqlDriverPlugin_event(QSqlDriverPlugin*, intptr_t, QEvent*);
+bool miqt_exec_callback_QSqlDriverPlugin_eventFilter(QSqlDriverPlugin*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_timerEvent(QSqlDriverPlugin*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_childEvent(QSqlDriverPlugin*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_customEvent(QSqlDriverPlugin*, intptr_t, QEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_connectNotify(QSqlDriverPlugin*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QSqlDriverPlugin_disconnectNotify(QSqlDriverPlugin*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQSqlDriverPlugin final : public QSqlDriverPlugin {
+public:
+
+	MiqtVirtualQSqlDriverPlugin(): QSqlDriverPlugin() {}
+	MiqtVirtualQSqlDriverPlugin(QObject* parent): QSqlDriverPlugin(parent) {}
+
+	virtual ~MiqtVirtualQSqlDriverPlugin() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__create = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QSqlDriver* create(const QString& key) override {
+		if (handle__create == 0) {
+			return nullptr; // Pure virtual, there is no base we can call
+		}
+
+		const QString key_ret = key;
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray key_b = key_ret.toUtf8();
+		struct miqt_string key_ms;
+		key_ms.len = key_b.length();
+		key_ms.data = static_cast<char*>(malloc(key_ms.len));
+		memcpy(key_ms.data, key_b.data(), key_ms.len);
+		struct miqt_string sigval1 = key_ms;
+		QSqlDriver* callback_return_value = miqt_exec_callback_QSqlDriverPlugin_create(this, handle__create, sigval1);
+		return callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__event == 0) {
+			return QSqlDriverPlugin::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QSqlDriverPlugin_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QSqlDriverPlugin_virtualbase_event(void* self, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__eventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__eventFilter == 0) {
+			return QSqlDriverPlugin::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QSqlDriverPlugin_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QSqlDriverPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__timerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__timerEvent == 0) {
+			QSqlDriverPlugin::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QSqlDriverPlugin_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__childEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__childEvent == 0) {
+			QSqlDriverPlugin::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QSqlDriverPlugin_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_childEvent(void* self, QChildEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__customEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__customEvent == 0) {
+			QSqlDriverPlugin::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QSqlDriverPlugin_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_customEvent(void* self, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__connectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__connectNotify == 0) {
+			QSqlDriverPlugin::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QSqlDriverPlugin_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__disconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__disconnectNotify == 0) {
+			QSqlDriverPlugin::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QSqlDriverPlugin_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QSqlDriverPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QSqlDriverPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QSqlDriverPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QSqlDriverPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QSqlDriverPlugin* QSqlDriverPlugin_new() {
+	return new (std::nothrow) MiqtVirtualQSqlDriverPlugin();
+}
+
+QSqlDriverPlugin* QSqlDriverPlugin_new2(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQSqlDriverPlugin(parent);
+}
+
+void QSqlDriverPlugin_virtbase(QSqlDriverPlugin* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QSqlDriverPlugin_metaObject(const QSqlDriverPlugin* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QSqlDriverPlugin_metacast(QSqlDriverPlugin* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QSqlDriverPlugin_tr(const char* s) {
+	QString _ret = QSqlDriverPlugin::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDriverPlugin_trUtf8(const char* s) {
+	QString _ret = QSqlDriverPlugin::trUtf8(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QSqlDriver* QSqlDriverPlugin_create(QSqlDriverPlugin* self, struct miqt_string key) {
+	QString key_QString = QString::fromUtf8(key.data, key.len);
+	return self->create(key_QString);
+}
+
+struct miqt_string QSqlDriverPlugin_tr2(const char* s, const char* c) {
+	QString _ret = QSqlDriverPlugin::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDriverPlugin_tr3(const char* s, const char* c, int n) {
+	QString _ret = QSqlDriverPlugin::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDriverPlugin_trUtf82(const char* s, const char* c) {
+	QString _ret = QSqlDriverPlugin::trUtf8(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDriverPlugin_trUtf83(const char* s, const char* c, int n) {
+	QString _ret = QSqlDriverPlugin::trUtf8(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QSqlDriverPlugin_override_virtual_create(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__create = slot;
+	return true;
+}
+
+bool QSqlDriverPlugin_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QSqlDriverPlugin_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::event(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QSqlDriverPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::eventFilter(watched, event);
+}
+
+bool QSqlDriverPlugin_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::timerEvent(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::childEvent(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::customEvent(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::connectNotify(*signal);
+}
+
+bool QSqlDriverPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::disconnectNotify(*signal);
+}
+
+QObject* QSqlDriverPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QSqlDriverPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QSqlDriverPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QSqlDriverPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QSqlDriverPlugin_delete(QSqlDriverPlugin* self) {
+	delete self;
+}
+

qt/sql/gen_qsqldriverplugin.go

@@ -0,0 +1,429 @@
+package sql
+
+/*
+
+#include "gen_qsqldriverplugin.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt"
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QSqlDriverPlugin struct {
+	h *C.QSqlDriverPlugin
+	*qt.QObject
+}
+
+func (this *QSqlDriverPlugin) cPointer() *C.QSqlDriverPlugin {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlDriverPlugin) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlDriverPlugin constructs the type using only CGO pointers.
+func newQSqlDriverPlugin(h *C.QSqlDriverPlugin) *QSqlDriverPlugin {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QSqlDriverPlugin_virtbase(h, &outptr_QObject)
+
+	return &QSqlDriverPlugin{h: h,
+		QObject: qt.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))}
+}
+
+// UnsafeNewQSqlDriverPlugin constructs the type using only unsafe pointers.
+func UnsafeNewQSqlDriverPlugin(h unsafe.Pointer) *QSqlDriverPlugin {
+	return newQSqlDriverPlugin((*C.QSqlDriverPlugin)(h))
+}
+
+// NewQSqlDriverPlugin constructs a new QSqlDriverPlugin object.
+func NewQSqlDriverPlugin() *QSqlDriverPlugin {
+
+	return newQSqlDriverPlugin(C.QSqlDriverPlugin_new())
+}
+
+// NewQSqlDriverPlugin2 constructs a new QSqlDriverPlugin object.
+func NewQSqlDriverPlugin2(parent *qt.QObject) *QSqlDriverPlugin {
+
+	return newQSqlDriverPlugin(C.QSqlDriverPlugin_new2((*C.QObject)(parent.UnsafePointer())))
+}
+
+func (this *QSqlDriverPlugin) MetaObject() *qt.QMetaObject {
+	return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QSqlDriverPlugin_metaObject(this.h)))
+}
+
+func (this *QSqlDriverPlugin) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QSqlDriverPlugin_metacast(this.h, param1_Cstring))
+}
+
+func QSqlDriverPlugin_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSqlDriverPlugin_TrUtf8(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_trUtf8(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDriverPlugin) Create(key string) *QSqlDriver {
+	key_ms := C.struct_miqt_string{}
+	key_ms.data = C.CString(key)
+	key_ms.len = C.size_t(len(key))
+	defer C.free(unsafe.Pointer(key_ms.data))
+	return newQSqlDriver(C.QSqlDriverPlugin_create(this.h, key_ms))
+}
+
+func QSqlDriverPlugin_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSqlDriverPlugin_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSqlDriverPlugin_TrUtf82(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_trUtf82(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSqlDriverPlugin_TrUtf83(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_trUtf83(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+// Sender can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) Sender() *qt.QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := qt.UnsafeNewQObject(unsafe.Pointer(C.QSqlDriverPlugin_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h))))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QSqlDriverPlugin_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QSqlDriverPlugin_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) IsSignalConnected(signal *qt.QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QSqlDriverPlugin_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+func (this *QSqlDriverPlugin) OnCreate(slot func(key string) *QSqlDriver) {
+	ok := C.QSqlDriverPlugin_override_virtual_create(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_create
+func miqt_exec_callback_QSqlDriverPlugin_create(self *C.QSqlDriverPlugin, cb C.intptr_t, key C.struct_miqt_string) *C.QSqlDriver {
+	gofunc, ok := cgo.Handle(cb).Value().(func(key string) *QSqlDriver)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var key_ms C.struct_miqt_string = key
+	key_ret := C.GoStringN(key_ms.data, C.int(int64(key_ms.len)))
+	C.free(unsafe.Pointer(key_ms.data))
+	slotval1 := key_ret
+
+	virtualReturn := gofunc(slotval1)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_Event(event *qt.QEvent) bool {
+
+	return (bool)(C.QSqlDriverPlugin_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QSqlDriverPlugin) OnEvent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) {
+	ok := C.QSqlDriverPlugin_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_event
+func miqt_exec_callback_QSqlDriverPlugin_event(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool {
+
+	return (bool)(C.QSqlDriverPlugin_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QSqlDriverPlugin) OnEventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) {
+	ok := C.QSqlDriverPlugin_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_eventFilter
+func miqt_exec_callback_QSqlDriverPlugin_eventFilter(self *C.QSqlDriverPlugin, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched))
+
+	slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_TimerEvent(event *qt.QTimerEvent) {
+
+	C.QSqlDriverPlugin_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnTimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) {
+	ok := C.QSqlDriverPlugin_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_timerEvent
+func miqt_exec_callback_QSqlDriverPlugin_timerEvent(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_ChildEvent(event *qt.QChildEvent) {
+
+	C.QSqlDriverPlugin_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnChildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) {
+	ok := C.QSqlDriverPlugin_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_childEvent
+func miqt_exec_callback_QSqlDriverPlugin_childEvent(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_CustomEvent(event *qt.QEvent) {
+
+	C.QSqlDriverPlugin_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnCustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) {
+	ok := C.QSqlDriverPlugin_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_customEvent
+func miqt_exec_callback_QSqlDriverPlugin_customEvent(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) {
+
+	C.QSqlDriverPlugin_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnConnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) {
+	ok := C.QSqlDriverPlugin_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_connectNotify
+func miqt_exec_callback_QSqlDriverPlugin_connectNotify(self *C.QSqlDriverPlugin, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) {
+
+	C.QSqlDriverPlugin_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnDisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) {
+	ok := C.QSqlDriverPlugin_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_disconnectNotify
+func miqt_exec_callback_QSqlDriverPlugin_disconnectNotify(self *C.QSqlDriverPlugin, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlDriverPlugin) Delete() {
+	C.QSqlDriverPlugin_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlDriverPlugin) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlDriverPlugin) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqldriverplugin.h

@@ -0,0 +1,78 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLDRIVERPLUGIN_H
+#define MIQT_QT_SQL_GEN_QSQLDRIVERPLUGIN_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QSqlDriver;
+class QSqlDriverPlugin;
+class QTimerEvent;
+#else
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlDriverPlugin QSqlDriverPlugin;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+QSqlDriverPlugin* QSqlDriverPlugin_new();
+QSqlDriverPlugin* QSqlDriverPlugin_new2(QObject* parent);
+void QSqlDriverPlugin_virtbase(QSqlDriverPlugin* src, QObject** outptr_QObject);
+QMetaObject* QSqlDriverPlugin_metaObject(const QSqlDriverPlugin* self);
+void* QSqlDriverPlugin_metacast(QSqlDriverPlugin* self, const char* param1);
+struct miqt_string QSqlDriverPlugin_tr(const char* s);
+struct miqt_string QSqlDriverPlugin_trUtf8(const char* s);
+QSqlDriver* QSqlDriverPlugin_create(QSqlDriverPlugin* self, struct miqt_string key);
+struct miqt_string QSqlDriverPlugin_tr2(const char* s, const char* c);
+struct miqt_string QSqlDriverPlugin_tr3(const char* s, const char* c, int n);
+struct miqt_string QSqlDriverPlugin_trUtf82(const char* s, const char* c);
+struct miqt_string QSqlDriverPlugin_trUtf83(const char* s, const char* c, int n);
+
+bool QSqlDriverPlugin_override_virtual_create(void* self, intptr_t slot);
+QSqlDriver* QSqlDriverPlugin_virtualbase_create(void* self, struct miqt_string key);
+bool QSqlDriverPlugin_override_virtual_event(void* self, intptr_t slot);
+bool QSqlDriverPlugin_virtualbase_event(void* self, QEvent* event);
+bool QSqlDriverPlugin_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlDriverPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlDriverPlugin_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlDriverPlugin_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlDriverPlugin_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlDriverPlugin_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlDriverPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QSqlDriverPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriverPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriverPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlDriverPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlDriverPlugin_delete(QSqlDriverPlugin* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlerror.cpp

@@ -0,0 +1,148 @@
+#include <QSqlError>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qsqlerror.h>
+#include "gen_qsqlerror.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlError* QSqlError_new(struct miqt_string driverText, struct miqt_string databaseText, int type, int number) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	return new (std::nothrow) QSqlError(driverText_QString, databaseText_QString, static_cast<QSqlError::ErrorType>(type), static_cast<int>(number));
+}
+
+QSqlError* QSqlError_new2() {
+	return new (std::nothrow) QSqlError();
+}
+
+QSqlError* QSqlError_new3(QSqlError* other) {
+	return new (std::nothrow) QSqlError(*other);
+}
+
+QSqlError* QSqlError_new4(struct miqt_string driverText) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	return new (std::nothrow) QSqlError(driverText_QString);
+}
+
+QSqlError* QSqlError_new5(struct miqt_string driverText, struct miqt_string databaseText) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	return new (std::nothrow) QSqlError(driverText_QString, databaseText_QString);
+}
+
+QSqlError* QSqlError_new6(struct miqt_string driverText, struct miqt_string databaseText, int type) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	return new (std::nothrow) QSqlError(driverText_QString, databaseText_QString, static_cast<QSqlError::ErrorType>(type));
+}
+
+QSqlError* QSqlError_new7(struct miqt_string driverText, struct miqt_string databaseText, int type, struct miqt_string errorCode) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	QString errorCode_QString = QString::fromUtf8(errorCode.data, errorCode.len);
+	return new (std::nothrow) QSqlError(driverText_QString, databaseText_QString, static_cast<QSqlError::ErrorType>(type), errorCode_QString);
+}
+
+void QSqlError_operatorAssign(QSqlError* self, QSqlError* other) {
+	self->operator=(*other);
+}
+
+bool QSqlError_operatorEqual(const QSqlError* self, QSqlError* other) {
+	return (*self == *other);
+}
+
+bool QSqlError_operatorNotEqual(const QSqlError* self, QSqlError* other) {
+	return (*self != *other);
+}
+
+void QSqlError_swap(QSqlError* self, QSqlError* other) {
+	self->swap(*other);
+}
+
+struct miqt_string QSqlError_driverText(const QSqlError* self) {
+	QString _ret = self->driverText();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlError_databaseText(const QSqlError* self) {
+	QString _ret = self->databaseText();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QSqlError_type(const QSqlError* self) {
+	QSqlError::ErrorType _ret = self->type();
+	return static_cast<int>(_ret);
+}
+
+int QSqlError_number(const QSqlError* self) {
+	return self->number();
+}
+
+struct miqt_string QSqlError_nativeErrorCode(const QSqlError* self) {
+	QString _ret = self->nativeErrorCode();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlError_text(const QSqlError* self) {
+	QString _ret = self->text();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QSqlError_isValid(const QSqlError* self) {
+	return self->isValid();
+}
+
+void QSqlError_setDriverText(QSqlError* self, struct miqt_string driverText) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	self->setDriverText(driverText_QString);
+}
+
+void QSqlError_setDatabaseText(QSqlError* self, struct miqt_string databaseText) {
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	self->setDatabaseText(databaseText_QString);
+}
+
+void QSqlError_setType(QSqlError* self, int type) {
+	self->setType(static_cast<QSqlError::ErrorType>(type));
+}
+
+void QSqlError_setNumber(QSqlError* self, int number) {
+	self->setNumber(static_cast<int>(number));
+}
+
+void QSqlError_delete(QSqlError* self) {
+	delete self;
+}
+

qt/sql/gen_qsqlerror.go

@@ -0,0 +1,232 @@
+package sql
+
+/*
+
+#include "gen_qsqlerror.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSqlError__ErrorType int
+
+const (
+	QSqlError__NoError          QSqlError__ErrorType = 0
+	QSqlError__ConnectionError  QSqlError__ErrorType = 1
+	QSqlError__StatementError   QSqlError__ErrorType = 2
+	QSqlError__TransactionError QSqlError__ErrorType = 3
+	QSqlError__UnknownError     QSqlError__ErrorType = 4
+)
+
+type QSqlError struct {
+	h *C.QSqlError
+}
+
+func (this *QSqlError) cPointer() *C.QSqlError {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlError) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlError constructs the type using only CGO pointers.
+func newQSqlError(h *C.QSqlError) *QSqlError {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlError{h: h}
+}
+
+// UnsafeNewQSqlError constructs the type using only unsafe pointers.
+func UnsafeNewQSqlError(h unsafe.Pointer) *QSqlError {
+	return newQSqlError((*C.QSqlError)(h))
+}
+
+// NewQSqlError constructs a new QSqlError object.
+func NewQSqlError(driverText string, databaseText string, typeVal QSqlError__ErrorType, number int) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+
+	return newQSqlError(C.QSqlError_new(driverText_ms, databaseText_ms, (C.int)(typeVal), (C.int)(number)))
+}
+
+// NewQSqlError2 constructs a new QSqlError object.
+func NewQSqlError2() *QSqlError {
+
+	return newQSqlError(C.QSqlError_new2())
+}
+
+// NewQSqlError3 constructs a new QSqlError object.
+func NewQSqlError3(other *QSqlError) *QSqlError {
+
+	return newQSqlError(C.QSqlError_new3(other.cPointer()))
+}
+
+// NewQSqlError4 constructs a new QSqlError object.
+func NewQSqlError4(driverText string) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+
+	return newQSqlError(C.QSqlError_new4(driverText_ms))
+}
+
+// NewQSqlError5 constructs a new QSqlError object.
+func NewQSqlError5(driverText string, databaseText string) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+
+	return newQSqlError(C.QSqlError_new5(driverText_ms, databaseText_ms))
+}
+
+// NewQSqlError6 constructs a new QSqlError object.
+func NewQSqlError6(driverText string, databaseText string, typeVal QSqlError__ErrorType) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+
+	return newQSqlError(C.QSqlError_new6(driverText_ms, databaseText_ms, (C.int)(typeVal)))
+}
+
+// NewQSqlError7 constructs a new QSqlError object.
+func NewQSqlError7(driverText string, databaseText string, typeVal QSqlError__ErrorType, errorCode string) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+	errorCode_ms := C.struct_miqt_string{}
+	errorCode_ms.data = C.CString(errorCode)
+	errorCode_ms.len = C.size_t(len(errorCode))
+	defer C.free(unsafe.Pointer(errorCode_ms.data))
+
+	return newQSqlError(C.QSqlError_new7(driverText_ms, databaseText_ms, (C.int)(typeVal), errorCode_ms))
+}
+
+func (this *QSqlError) OperatorAssign(other *QSqlError) {
+	C.QSqlError_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlError) OperatorEqual(other *QSqlError) bool {
+	return (bool)(C.QSqlError_operatorEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlError) OperatorNotEqual(other *QSqlError) bool {
+	return (bool)(C.QSqlError_operatorNotEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlError) Swap(other *QSqlError) {
+	C.QSqlError_swap(this.h, other.cPointer())
+}
+
+func (this *QSqlError) DriverText() string {
+	var _ms C.struct_miqt_string = C.QSqlError_driverText(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) DatabaseText() string {
+	var _ms C.struct_miqt_string = C.QSqlError_databaseText(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) Type() QSqlError__ErrorType {
+	return (QSqlError__ErrorType)(C.QSqlError_type(this.h))
+}
+
+func (this *QSqlError) Number() int {
+	return (int)(C.QSqlError_number(this.h))
+}
+
+func (this *QSqlError) NativeErrorCode() string {
+	var _ms C.struct_miqt_string = C.QSqlError_nativeErrorCode(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) Text() string {
+	var _ms C.struct_miqt_string = C.QSqlError_text(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) IsValid() bool {
+	return (bool)(C.QSqlError_isValid(this.h))
+}
+
+func (this *QSqlError) SetDriverText(driverText string) {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	C.QSqlError_setDriverText(this.h, driverText_ms)
+}
+
+func (this *QSqlError) SetDatabaseText(databaseText string) {
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+	C.QSqlError_setDatabaseText(this.h, databaseText_ms)
+}
+
+func (this *QSqlError) SetType(typeVal QSqlError__ErrorType) {
+	C.QSqlError_setType(this.h, (C.int)(typeVal))
+}
+
+func (this *QSqlError) SetNumber(number int) {
+	C.QSqlError_setNumber(this.h, (C.int)(number))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlError) Delete() {
+	C.QSqlError_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlError) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlError) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqlerror.h

@@ -0,0 +1,52 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLERROR_H
+#define MIQT_QT_SQL_GEN_QSQLERROR_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlError;
+#else
+typedef struct QSqlError QSqlError;
+#endif
+
+QSqlError* QSqlError_new(struct miqt_string driverText, struct miqt_string databaseText, int type, int number);
+QSqlError* QSqlError_new2();
+QSqlError* QSqlError_new3(QSqlError* other);
+QSqlError* QSqlError_new4(struct miqt_string driverText);
+QSqlError* QSqlError_new5(struct miqt_string driverText, struct miqt_string databaseText);
+QSqlError* QSqlError_new6(struct miqt_string driverText, struct miqt_string databaseText, int type);
+QSqlError* QSqlError_new7(struct miqt_string driverText, struct miqt_string databaseText, int type, struct miqt_string errorCode);
+void QSqlError_operatorAssign(QSqlError* self, QSqlError* other);
+bool QSqlError_operatorEqual(const QSqlError* self, QSqlError* other);
+bool QSqlError_operatorNotEqual(const QSqlError* self, QSqlError* other);
+void QSqlError_swap(QSqlError* self, QSqlError* other);
+struct miqt_string QSqlError_driverText(const QSqlError* self);
+struct miqt_string QSqlError_databaseText(const QSqlError* self);
+int QSqlError_type(const QSqlError* self);
+int QSqlError_number(const QSqlError* self);
+struct miqt_string QSqlError_nativeErrorCode(const QSqlError* self);
+struct miqt_string QSqlError_text(const QSqlError* self);
+bool QSqlError_isValid(const QSqlError* self);
+void QSqlError_setDriverText(QSqlError* self, struct miqt_string driverText);
+void QSqlError_setDatabaseText(QSqlError* self, struct miqt_string databaseText);
+void QSqlError_setType(QSqlError* self, int type);
+void QSqlError_setNumber(QSqlError* self, int number);
+
+void QSqlError_delete(QSqlError* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlfield.cpp

@@ -0,0 +1,186 @@
+#include <QSqlField>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QVariant>
+#include <qsqlfield.h>
+#include "gen_qsqlfield.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlField* QSqlField_new() {
+	return new (std::nothrow) QSqlField();
+}
+
+QSqlField* QSqlField_new2(struct miqt_string fieldName, int type, struct miqt_string tableName) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	QString tableName_QString = QString::fromUtf8(tableName.data, tableName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString, static_cast<QVariant::Type>(type), tableName_QString);
+}
+
+QSqlField* QSqlField_new3(QSqlField* other) {
+	return new (std::nothrow) QSqlField(*other);
+}
+
+QSqlField* QSqlField_new4(struct miqt_string fieldName) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString);
+}
+
+QSqlField* QSqlField_new5(struct miqt_string fieldName, int type) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString, static_cast<QVariant::Type>(type));
+}
+
+void QSqlField_operatorAssign(QSqlField* self, QSqlField* other) {
+	self->operator=(*other);
+}
+
+bool QSqlField_operatorEqual(const QSqlField* self, QSqlField* other) {
+	return (*self == *other);
+}
+
+bool QSqlField_operatorNotEqual(const QSqlField* self, QSqlField* other) {
+	return (*self != *other);
+}
+
+void QSqlField_setValue(QSqlField* self, QVariant* value) {
+	self->setValue(*value);
+}
+
+QVariant* QSqlField_value(const QSqlField* self) {
+	return new QVariant(self->value());
+}
+
+void QSqlField_setName(QSqlField* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setName(name_QString);
+}
+
+struct miqt_string QSqlField_name(const QSqlField* self) {
+	QString _ret = self->name();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlField_setTableName(QSqlField* self, struct miqt_string tableName) {
+	QString tableName_QString = QString::fromUtf8(tableName.data, tableName.len);
+	self->setTableName(tableName_QString);
+}
+
+struct miqt_string QSqlField_tableName(const QSqlField* self) {
+	QString _ret = self->tableName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QSqlField_isNull(const QSqlField* self) {
+	return self->isNull();
+}
+
+void QSqlField_setReadOnly(QSqlField* self, bool readOnly) {
+	self->setReadOnly(readOnly);
+}
+
+bool QSqlField_isReadOnly(const QSqlField* self) {
+	return self->isReadOnly();
+}
+
+void QSqlField_clear(QSqlField* self) {
+	self->clear();
+}
+
+int QSqlField_type(const QSqlField* self) {
+	QVariant::Type _ret = self->type();
+	return static_cast<int>(_ret);
+}
+
+bool QSqlField_isAutoValue(const QSqlField* self) {
+	return self->isAutoValue();
+}
+
+void QSqlField_setType(QSqlField* self, int type) {
+	self->setType(static_cast<QVariant::Type>(type));
+}
+
+void QSqlField_setRequiredStatus(QSqlField* self, int status) {
+	self->setRequiredStatus(static_cast<QSqlField::RequiredStatus>(status));
+}
+
+void QSqlField_setRequired(QSqlField* self, bool required) {
+	self->setRequired(required);
+}
+
+void QSqlField_setLength(QSqlField* self, int fieldLength) {
+	self->setLength(static_cast<int>(fieldLength));
+}
+
+void QSqlField_setPrecision(QSqlField* self, int precision) {
+	self->setPrecision(static_cast<int>(precision));
+}
+
+void QSqlField_setDefaultValue(QSqlField* self, QVariant* value) {
+	self->setDefaultValue(*value);
+}
+
+void QSqlField_setSqlType(QSqlField* self, int type) {
+	self->setSqlType(static_cast<int>(type));
+}
+
+void QSqlField_setGenerated(QSqlField* self, bool gen) {
+	self->setGenerated(gen);
+}
+
+void QSqlField_setAutoValue(QSqlField* self, bool autoVal) {
+	self->setAutoValue(autoVal);
+}
+
+int QSqlField_requiredStatus(const QSqlField* self) {
+	QSqlField::RequiredStatus _ret = self->requiredStatus();
+	return static_cast<int>(_ret);
+}
+
+int QSqlField_length(const QSqlField* self) {
+	return self->length();
+}
+
+int QSqlField_precision(const QSqlField* self) {
+	return self->precision();
+}
+
+QVariant* QSqlField_defaultValue(const QSqlField* self) {
+	return new QVariant(self->defaultValue());
+}
+
+int QSqlField_typeID(const QSqlField* self) {
+	return self->typeID();
+}
+
+bool QSqlField_isGenerated(const QSqlField* self) {
+	return self->isGenerated();
+}
+
+bool QSqlField_isValid(const QSqlField* self) {
+	return self->isValid();
+}
+
+void QSqlField_delete(QSqlField* self) {
+	delete self;
+}
+

qt/sql/gen_qsqlfield.go

@@ -0,0 +1,257 @@
+package sql
+
+/*
+
+#include "gen_qsqlfield.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt"
+	"runtime"
+	"unsafe"
+)
+
+type QSqlField__RequiredStatus int
+
+const (
+	QSqlField__Unknown  QSqlField__RequiredStatus = -1
+	QSqlField__Optional QSqlField__RequiredStatus = 0
+	QSqlField__Required QSqlField__RequiredStatus = 1
+)
+
+type QSqlField struct {
+	h *C.QSqlField
+}
+
+func (this *QSqlField) cPointer() *C.QSqlField {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlField) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlField constructs the type using only CGO pointers.
+func newQSqlField(h *C.QSqlField) *QSqlField {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlField{h: h}
+}
+
+// UnsafeNewQSqlField constructs the type using only unsafe pointers.
+func UnsafeNewQSqlField(h unsafe.Pointer) *QSqlField {
+	return newQSqlField((*C.QSqlField)(h))
+}
+
+// NewQSqlField constructs a new QSqlField object.
+func NewQSqlField() *QSqlField {
+
+	return newQSqlField(C.QSqlField_new())
+}
+
+// NewQSqlField2 constructs a new QSqlField object.
+func NewQSqlField2(fieldName string, typeVal qt.QVariant__Type, tableName string) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+	tableName_ms := C.struct_miqt_string{}
+	tableName_ms.data = C.CString(tableName)
+	tableName_ms.len = C.size_t(len(tableName))
+	defer C.free(unsafe.Pointer(tableName_ms.data))
+
+	return newQSqlField(C.QSqlField_new2(fieldName_ms, (C.int)(typeVal), tableName_ms))
+}
+
+// NewQSqlField3 constructs a new QSqlField object.
+func NewQSqlField3(other *QSqlField) *QSqlField {
+
+	return newQSqlField(C.QSqlField_new3(other.cPointer()))
+}
+
+// NewQSqlField4 constructs a new QSqlField object.
+func NewQSqlField4(fieldName string) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+
+	return newQSqlField(C.QSqlField_new4(fieldName_ms))
+}
+
+// NewQSqlField5 constructs a new QSqlField object.
+func NewQSqlField5(fieldName string, typeVal qt.QVariant__Type) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+
+	return newQSqlField(C.QSqlField_new5(fieldName_ms, (C.int)(typeVal)))
+}
+
+func (this *QSqlField) OperatorAssign(other *QSqlField) {
+	C.QSqlField_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlField) OperatorEqual(other *QSqlField) bool {
+	return (bool)(C.QSqlField_operatorEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlField) OperatorNotEqual(other *QSqlField) bool {
+	return (bool)(C.QSqlField_operatorNotEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlField) SetValue(value *qt.QVariant) {
+	C.QSqlField_setValue(this.h, (*C.QVariant)(value.UnsafePointer()))
+}
+
+func (this *QSqlField) Value() *qt.QVariant {
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlField_value(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlField) SetName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlField_setName(this.h, name_ms)
+}
+
+func (this *QSqlField) Name() string {
+	var _ms C.struct_miqt_string = C.QSqlField_name(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlField) SetTableName(tableName string) {
+	tableName_ms := C.struct_miqt_string{}
+	tableName_ms.data = C.CString(tableName)
+	tableName_ms.len = C.size_t(len(tableName))
+	defer C.free(unsafe.Pointer(tableName_ms.data))
+	C.QSqlField_setTableName(this.h, tableName_ms)
+}
+
+func (this *QSqlField) TableName() string {
+	var _ms C.struct_miqt_string = C.QSqlField_tableName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlField) IsNull() bool {
+	return (bool)(C.QSqlField_isNull(this.h))
+}
+
+func (this *QSqlField) SetReadOnly(readOnly bool) {
+	C.QSqlField_setReadOnly(this.h, (C.bool)(readOnly))
+}
+
+func (this *QSqlField) IsReadOnly() bool {
+	return (bool)(C.QSqlField_isReadOnly(this.h))
+}
+
+func (this *QSqlField) Clear() {
+	C.QSqlField_clear(this.h)
+}
+
+func (this *QSqlField) Type() qt.QVariant__Type {
+	return (qt.QVariant__Type)(C.QSqlField_type(this.h))
+}
+
+func (this *QSqlField) IsAutoValue() bool {
+	return (bool)(C.QSqlField_isAutoValue(this.h))
+}
+
+func (this *QSqlField) SetType(typeVal qt.QVariant__Type) {
+	C.QSqlField_setType(this.h, (C.int)(typeVal))
+}
+
+func (this *QSqlField) SetRequiredStatus(status QSqlField__RequiredStatus) {
+	C.QSqlField_setRequiredStatus(this.h, (C.int)(status))
+}
+
+func (this *QSqlField) SetRequired(required bool) {
+	C.QSqlField_setRequired(this.h, (C.bool)(required))
+}
+
+func (this *QSqlField) SetLength(fieldLength int) {
+	C.QSqlField_setLength(this.h, (C.int)(fieldLength))
+}
+
+func (this *QSqlField) SetPrecision(precision int) {
+	C.QSqlField_setPrecision(this.h, (C.int)(precision))
+}
+
+func (this *QSqlField) SetDefaultValue(value *qt.QVariant) {
+	C.QSqlField_setDefaultValue(this.h, (*C.QVariant)(value.UnsafePointer()))
+}
+
+func (this *QSqlField) SetSqlType(typeVal int) {
+	C.QSqlField_setSqlType(this.h, (C.int)(typeVal))
+}
+
+func (this *QSqlField) SetGenerated(gen bool) {
+	C.QSqlField_setGenerated(this.h, (C.bool)(gen))
+}
+
+func (this *QSqlField) SetAutoValue(autoVal bool) {
+	C.QSqlField_setAutoValue(this.h, (C.bool)(autoVal))
+}
+
+func (this *QSqlField) RequiredStatus() QSqlField__RequiredStatus {
+	return (QSqlField__RequiredStatus)(C.QSqlField_requiredStatus(this.h))
+}
+
+func (this *QSqlField) Length() int {
+	return (int)(C.QSqlField_length(this.h))
+}
+
+func (this *QSqlField) Precision() int {
+	return (int)(C.QSqlField_precision(this.h))
+}
+
+func (this *QSqlField) DefaultValue() *qt.QVariant {
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlField_defaultValue(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlField) TypeID() int {
+	return (int)(C.QSqlField_typeID(this.h))
+}
+
+func (this *QSqlField) IsGenerated() bool {
+	return (bool)(C.QSqlField_isGenerated(this.h))
+}
+
+func (this *QSqlField) IsValid() bool {
+	return (bool)(C.QSqlField_isValid(this.h))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlField) Delete() {
+	C.QSqlField_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlField) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlField) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqlfield.h

@@ -0,0 +1,68 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLFIELD_H
+#define MIQT_QT_SQL_GEN_QSQLFIELD_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlField;
+class QVariant;
+#else
+typedef struct QSqlField QSqlField;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlField* QSqlField_new();
+QSqlField* QSqlField_new2(struct miqt_string fieldName, int type, struct miqt_string tableName);
+QSqlField* QSqlField_new3(QSqlField* other);
+QSqlField* QSqlField_new4(struct miqt_string fieldName);
+QSqlField* QSqlField_new5(struct miqt_string fieldName, int type);
+void QSqlField_operatorAssign(QSqlField* self, QSqlField* other);
+bool QSqlField_operatorEqual(const QSqlField* self, QSqlField* other);
+bool QSqlField_operatorNotEqual(const QSqlField* self, QSqlField* other);
+void QSqlField_setValue(QSqlField* self, QVariant* value);
+QVariant* QSqlField_value(const QSqlField* self);
+void QSqlField_setName(QSqlField* self, struct miqt_string name);
+struct miqt_string QSqlField_name(const QSqlField* self);
+void QSqlField_setTableName(QSqlField* self, struct miqt_string tableName);
+struct miqt_string QSqlField_tableName(const QSqlField* self);
+bool QSqlField_isNull(const QSqlField* self);
+void QSqlField_setReadOnly(QSqlField* self, bool readOnly);
+bool QSqlField_isReadOnly(const QSqlField* self);
+void QSqlField_clear(QSqlField* self);
+int QSqlField_type(const QSqlField* self);
+bool QSqlField_isAutoValue(const QSqlField* self);
+void QSqlField_setType(QSqlField* self, int type);
+void QSqlField_setRequiredStatus(QSqlField* self, int status);
+void QSqlField_setRequired(QSqlField* self, bool required);
+void QSqlField_setLength(QSqlField* self, int fieldLength);
+void QSqlField_setPrecision(QSqlField* self, int precision);
+void QSqlField_setDefaultValue(QSqlField* self, QVariant* value);
+void QSqlField_setSqlType(QSqlField* self, int type);
+void QSqlField_setGenerated(QSqlField* self, bool gen);
+void QSqlField_setAutoValue(QSqlField* self, bool autoVal);
+int QSqlField_requiredStatus(const QSqlField* self);
+int QSqlField_length(const QSqlField* self);
+int QSqlField_precision(const QSqlField* self);
+QVariant* QSqlField_defaultValue(const QSqlField* self);
+int QSqlField_typeID(const QSqlField* self);
+bool QSqlField_isGenerated(const QSqlField* self);
+bool QSqlField_isValid(const QSqlField* self);
+
+void QSqlField_delete(QSqlField* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlindex.cpp

@@ -0,0 +1,96 @@
+#include <QSqlField>
+#include <QSqlIndex>
+#include <QSqlRecord>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qsqlindex.h>
+#include "gen_qsqlindex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlIndex* QSqlIndex_new() {
+	return new (std::nothrow) QSqlIndex();
+}
+
+QSqlIndex* QSqlIndex_new2(QSqlIndex* other) {
+	return new (std::nothrow) QSqlIndex(*other);
+}
+
+QSqlIndex* QSqlIndex_new3(struct miqt_string cursorName) {
+	QString cursorName_QString = QString::fromUtf8(cursorName.data, cursorName.len);
+	return new (std::nothrow) QSqlIndex(cursorName_QString);
+}
+
+QSqlIndex* QSqlIndex_new4(struct miqt_string cursorName, struct miqt_string name) {
+	QString cursorName_QString = QString::fromUtf8(cursorName.data, cursorName.len);
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new (std::nothrow) QSqlIndex(cursorName_QString, name_QString);
+}
+
+void QSqlIndex_virtbase(QSqlIndex* src, QSqlRecord** outptr_QSqlRecord) {
+	*outptr_QSqlRecord = static_cast<QSqlRecord*>(src);
+}
+
+void QSqlIndex_operatorAssign(QSqlIndex* self, QSqlIndex* other) {
+	self->operator=(*other);
+}
+
+void QSqlIndex_setCursorName(QSqlIndex* self, struct miqt_string cursorName) {
+	QString cursorName_QString = QString::fromUtf8(cursorName.data, cursorName.len);
+	self->setCursorName(cursorName_QString);
+}
+
+struct miqt_string QSqlIndex_cursorName(const QSqlIndex* self) {
+	QString _ret = self->cursorName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlIndex_setName(QSqlIndex* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setName(name_QString);
+}
+
+struct miqt_string QSqlIndex_name(const QSqlIndex* self) {
+	QString _ret = self->name();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlIndex_append(QSqlIndex* self, QSqlField* field) {
+	self->append(*field);
+}
+
+void QSqlIndex_append2(QSqlIndex* self, QSqlField* field, bool desc) {
+	self->append(*field, desc);
+}
+
+bool QSqlIndex_isDescending(const QSqlIndex* self, int i) {
+	return self->isDescending(static_cast<int>(i));
+}
+
+void QSqlIndex_setDescending(QSqlIndex* self, int i, bool desc) {
+	self->setDescending(static_cast<int>(i), desc);
+}
+
+void QSqlIndex_delete(QSqlIndex* self) {
+	delete self;
+}
+

qt/sql/gen_qsqlindex.go

@@ -0,0 +1,150 @@
+package sql
+
+/*
+
+#include "gen_qsqlindex.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSqlIndex struct {
+	h *C.QSqlIndex
+	*QSqlRecord
+}
+
+func (this *QSqlIndex) cPointer() *C.QSqlIndex {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlIndex) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlIndex constructs the type using only CGO pointers.
+func newQSqlIndex(h *C.QSqlIndex) *QSqlIndex {
+	if h == nil {
+		return nil
+	}
+	var outptr_QSqlRecord *C.QSqlRecord = nil
+	C.QSqlIndex_virtbase(h, &outptr_QSqlRecord)
+
+	return &QSqlIndex{h: h,
+		QSqlRecord: newQSqlRecord(outptr_QSqlRecord)}
+}
+
+// UnsafeNewQSqlIndex constructs the type using only unsafe pointers.
+func UnsafeNewQSqlIndex(h unsafe.Pointer) *QSqlIndex {
+	return newQSqlIndex((*C.QSqlIndex)(h))
+}
+
+// NewQSqlIndex constructs a new QSqlIndex object.
+func NewQSqlIndex() *QSqlIndex {
+
+	return newQSqlIndex(C.QSqlIndex_new())
+}
+
+// NewQSqlIndex2 constructs a new QSqlIndex object.
+func NewQSqlIndex2(other *QSqlIndex) *QSqlIndex {
+
+	return newQSqlIndex(C.QSqlIndex_new2(other.cPointer()))
+}
+
+// NewQSqlIndex3 constructs a new QSqlIndex object.
+func NewQSqlIndex3(cursorName string) *QSqlIndex {
+	cursorName_ms := C.struct_miqt_string{}
+	cursorName_ms.data = C.CString(cursorName)
+	cursorName_ms.len = C.size_t(len(cursorName))
+	defer C.free(unsafe.Pointer(cursorName_ms.data))
+
+	return newQSqlIndex(C.QSqlIndex_new3(cursorName_ms))
+}
+
+// NewQSqlIndex4 constructs a new QSqlIndex object.
+func NewQSqlIndex4(cursorName string, name string) *QSqlIndex {
+	cursorName_ms := C.struct_miqt_string{}
+	cursorName_ms.data = C.CString(cursorName)
+	cursorName_ms.len = C.size_t(len(cursorName))
+	defer C.free(unsafe.Pointer(cursorName_ms.data))
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+
+	return newQSqlIndex(C.QSqlIndex_new4(cursorName_ms, name_ms))
+}
+
+func (this *QSqlIndex) OperatorAssign(other *QSqlIndex) {
+	C.QSqlIndex_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlIndex) SetCursorName(cursorName string) {
+	cursorName_ms := C.struct_miqt_string{}
+	cursorName_ms.data = C.CString(cursorName)
+	cursorName_ms.len = C.size_t(len(cursorName))
+	defer C.free(unsafe.Pointer(cursorName_ms.data))
+	C.QSqlIndex_setCursorName(this.h, cursorName_ms)
+}
+
+func (this *QSqlIndex) CursorName() string {
+	var _ms C.struct_miqt_string = C.QSqlIndex_cursorName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlIndex) SetName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlIndex_setName(this.h, name_ms)
+}
+
+func (this *QSqlIndex) Name() string {
+	var _ms C.struct_miqt_string = C.QSqlIndex_name(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlIndex) Append(field *QSqlField) {
+	C.QSqlIndex_append(this.h, field.cPointer())
+}
+
+func (this *QSqlIndex) Append2(field *QSqlField, desc bool) {
+	C.QSqlIndex_append2(this.h, field.cPointer(), (C.bool)(desc))
+}
+
+func (this *QSqlIndex) IsDescending(i int) bool {
+	return (bool)(C.QSqlIndex_isDescending(this.h, (C.int)(i)))
+}
+
+func (this *QSqlIndex) SetDescending(i int, desc bool) {
+	C.QSqlIndex_setDescending(this.h, (C.int)(i), (C.bool)(desc))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlIndex) Delete() {
+	C.QSqlIndex_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlIndex) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlIndex) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqlindex.h

@@ -0,0 +1,48 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLINDEX_H
+#define MIQT_QT_SQL_GEN_QSQLINDEX_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlField;
+class QSqlIndex;
+class QSqlRecord;
+#else
+typedef struct QSqlField QSqlField;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlRecord QSqlRecord;
+#endif
+
+QSqlIndex* QSqlIndex_new();
+QSqlIndex* QSqlIndex_new2(QSqlIndex* other);
+QSqlIndex* QSqlIndex_new3(struct miqt_string cursorName);
+QSqlIndex* QSqlIndex_new4(struct miqt_string cursorName, struct miqt_string name);
+void QSqlIndex_virtbase(QSqlIndex* src, QSqlRecord** outptr_QSqlRecord);
+void QSqlIndex_operatorAssign(QSqlIndex* self, QSqlIndex* other);
+void QSqlIndex_setCursorName(QSqlIndex* self, struct miqt_string cursorName);
+struct miqt_string QSqlIndex_cursorName(const QSqlIndex* self);
+void QSqlIndex_setName(QSqlIndex* self, struct miqt_string name);
+struct miqt_string QSqlIndex_name(const QSqlIndex* self);
+void QSqlIndex_append(QSqlIndex* self, QSqlField* field);
+void QSqlIndex_append2(QSqlIndex* self, QSqlField* field, bool desc);
+bool QSqlIndex_isDescending(const QSqlIndex* self, int i);
+void QSqlIndex_setDescending(QSqlIndex* self, int i, bool desc);
+
+void QSqlIndex_delete(QSqlIndex* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlquery.cpp

@@ -0,0 +1,275 @@
+#include <QMap>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QSqlError>
+#include <QSqlQuery>
+#include <QSqlRecord>
+#include <QSqlResult>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QVariant>
+#include <qsqlquery.h>
+#include "gen_qsqlquery.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlQuery* QSqlQuery_new(QSqlResult* r) {
+	return new (std::nothrow) QSqlQuery(r);
+}
+
+QSqlQuery* QSqlQuery_new2() {
+	return new (std::nothrow) QSqlQuery();
+}
+
+QSqlQuery* QSqlQuery_new3(QSqlDatabase* db) {
+	return new (std::nothrow) QSqlQuery(*db);
+}
+
+QSqlQuery* QSqlQuery_new4(QSqlQuery* other) {
+	return new (std::nothrow) QSqlQuery(*other);
+}
+
+QSqlQuery* QSqlQuery_new5(struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return new (std::nothrow) QSqlQuery(query_QString);
+}
+
+QSqlQuery* QSqlQuery_new6(struct miqt_string query, QSqlDatabase* db) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return new (std::nothrow) QSqlQuery(query_QString, *db);
+}
+
+void QSqlQuery_operatorAssign(QSqlQuery* self, QSqlQuery* other) {
+	self->operator=(*other);
+}
+
+bool QSqlQuery_isValid(const QSqlQuery* self) {
+	return self->isValid();
+}
+
+bool QSqlQuery_isActive(const QSqlQuery* self) {
+	return self->isActive();
+}
+
+bool QSqlQuery_isNull(const QSqlQuery* self, int field) {
+	return self->isNull(static_cast<int>(field));
+}
+
+bool QSqlQuery_isNullWithName(const QSqlQuery* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->isNull(name_QString);
+}
+
+int QSqlQuery_at(const QSqlQuery* self) {
+	return self->at();
+}
+
+struct miqt_string QSqlQuery_lastQuery(const QSqlQuery* self) {
+	QString _ret = self->lastQuery();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QSqlQuery_numRowsAffected(const QSqlQuery* self) {
+	return self->numRowsAffected();
+}
+
+QSqlError* QSqlQuery_lastError(const QSqlQuery* self) {
+	return new QSqlError(self->lastError());
+}
+
+bool QSqlQuery_isSelect(const QSqlQuery* self) {
+	return self->isSelect();
+}
+
+int QSqlQuery_size(const QSqlQuery* self) {
+	return self->size();
+}
+
+QSqlDriver* QSqlQuery_driver(const QSqlQuery* self) {
+	return (QSqlDriver*) self->driver();
+}
+
+QSqlResult* QSqlQuery_result(const QSqlQuery* self) {
+	return (QSqlResult*) self->result();
+}
+
+bool QSqlQuery_isForwardOnly(const QSqlQuery* self) {
+	return self->isForwardOnly();
+}
+
+QSqlRecord* QSqlQuery_record(const QSqlQuery* self) {
+	return new QSqlRecord(self->record());
+}
+
+void QSqlQuery_setForwardOnly(QSqlQuery* self, bool forward) {
+	self->setForwardOnly(forward);
+}
+
+bool QSqlQuery_exec(QSqlQuery* self, struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return self->exec(query_QString);
+}
+
+QVariant* QSqlQuery_value(const QSqlQuery* self, int i) {
+	return new QVariant(self->value(static_cast<int>(i)));
+}
+
+QVariant* QSqlQuery_valueWithName(const QSqlQuery* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new QVariant(self->value(name_QString));
+}
+
+void QSqlQuery_setNumericalPrecisionPolicy(QSqlQuery* self, int precisionPolicy) {
+	self->setNumericalPrecisionPolicy(static_cast<QSql::NumericalPrecisionPolicy>(precisionPolicy));
+}
+
+int QSqlQuery_numericalPrecisionPolicy(const QSqlQuery* self) {
+	QSql::NumericalPrecisionPolicy _ret = self->numericalPrecisionPolicy();
+	return static_cast<int>(_ret);
+}
+
+bool QSqlQuery_seek(QSqlQuery* self, int i) {
+	return self->seek(static_cast<int>(i));
+}
+
+bool QSqlQuery_next(QSqlQuery* self) {
+	return self->next();
+}
+
+bool QSqlQuery_previous(QSqlQuery* self) {
+	return self->previous();
+}
+
+bool QSqlQuery_first(QSqlQuery* self) {
+	return self->first();
+}
+
+bool QSqlQuery_last(QSqlQuery* self) {
+	return self->last();
+}
+
+void QSqlQuery_clear(QSqlQuery* self) {
+	self->clear();
+}
+
+bool QSqlQuery_exec2(QSqlQuery* self) {
+	return self->exec();
+}
+
+bool QSqlQuery_execBatch(QSqlQuery* self) {
+	return self->execBatch();
+}
+
+bool QSqlQuery_prepare(QSqlQuery* self, struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return self->prepare(query_QString);
+}
+
+void QSqlQuery_bindValue(QSqlQuery* self, struct miqt_string placeholder, QVariant* val) {
+	QString placeholder_QString = QString::fromUtf8(placeholder.data, placeholder.len);
+	self->bindValue(placeholder_QString, *val);
+}
+
+void QSqlQuery_bindValue2(QSqlQuery* self, int pos, QVariant* val) {
+	self->bindValue(static_cast<int>(pos), *val);
+}
+
+void QSqlQuery_addBindValue(QSqlQuery* self, QVariant* val) {
+	self->addBindValue(*val);
+}
+
+QVariant* QSqlQuery_boundValue(const QSqlQuery* self, struct miqt_string placeholder) {
+	QString placeholder_QString = QString::fromUtf8(placeholder.data, placeholder.len);
+	return new QVariant(self->boundValue(placeholder_QString));
+}
+
+QVariant* QSqlQuery_boundValueWithPos(const QSqlQuery* self, int pos) {
+	return new QVariant(self->boundValue(static_cast<int>(pos)));
+}
+
+struct miqt_map /* of struct miqt_string to QVariant* */  QSqlQuery_boundValues(const QSqlQuery* self) {
+	QMap<QString, QVariant> _ret = self->boundValues();
+	// Convert QMap<> from C++ memory to manually-managed C memory
+	struct miqt_string* _karr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.size()));
+	QVariant** _varr = static_cast<QVariant**>(malloc(sizeof(QVariant*) * _ret.size()));
+	int _ctr = 0;
+	for (auto _itr = _ret.keyValueBegin(); _itr != _ret.keyValueEnd(); ++_itr) {
+		QString _mapkey_ret = _itr->first;
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _mapkey_b = _mapkey_ret.toUtf8();
+		struct miqt_string _mapkey_ms;
+		_mapkey_ms.len = _mapkey_b.length();
+		_mapkey_ms.data = static_cast<char*>(malloc(_mapkey_ms.len));
+		memcpy(_mapkey_ms.data, _mapkey_b.data(), _mapkey_ms.len);
+		_karr[_ctr] = _mapkey_ms;
+		_varr[_ctr] = new QVariant(_itr->second);
+		_ctr++;
+	}
+	struct miqt_map _out;
+	_out.len = _ret.size();
+	_out.keys = static_cast<void*>(_karr);
+	_out.values = static_cast<void*>(_varr);
+	return _out;
+}
+
+struct miqt_string QSqlQuery_executedQuery(const QSqlQuery* self) {
+	QString _ret = self->executedQuery();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QVariant* QSqlQuery_lastInsertId(const QSqlQuery* self) {
+	return new QVariant(self->lastInsertId());
+}
+
+void QSqlQuery_finish(QSqlQuery* self) {
+	self->finish();
+}
+
+bool QSqlQuery_nextResult(QSqlQuery* self) {
+	return self->nextResult();
+}
+
+bool QSqlQuery_seek2(QSqlQuery* self, int i, bool relative) {
+	return self->seek(static_cast<int>(i), relative);
+}
+
+bool QSqlQuery_execBatchWithMode(QSqlQuery* self, int mode) {
+	return self->execBatch(static_cast<QSqlQuery::BatchExecutionMode>(mode));
+}
+
+void QSqlQuery_bindValue3(QSqlQuery* self, struct miqt_string placeholder, QVariant* val, int type) {
+	QString placeholder_QString = QString::fromUtf8(placeholder.data, placeholder.len);
+	self->bindValue(placeholder_QString, *val, static_cast<QSql::ParamType>(type));
+}
+
+void QSqlQuery_bindValue4(QSqlQuery* self, int pos, QVariant* val, int type) {
+	self->bindValue(static_cast<int>(pos), *val, static_cast<QSql::ParamType>(type));
+}
+
+void QSqlQuery_addBindValue2(QSqlQuery* self, QVariant* val, int type) {
+	self->addBindValue(*val, static_cast<QSql::ParamType>(type));
+}
+
+void QSqlQuery_delete(QSqlQuery* self) {
+	delete self;
+}
+

qt/sql/gen_qsqlquery.go

@@ -0,0 +1,355 @@
+package sql
+
+/*
+
+#include "gen_qsqlquery.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt"
+	"runtime"
+	"unsafe"
+)
+
+type QSqlQuery__BatchExecutionMode int
+
+const (
+	QSqlQuery__ValuesAsRows    QSqlQuery__BatchExecutionMode = 0
+	QSqlQuery__ValuesAsColumns QSqlQuery__BatchExecutionMode = 1
+)
+
+type QSqlQuery struct {
+	h *C.QSqlQuery
+}
+
+func (this *QSqlQuery) cPointer() *C.QSqlQuery {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlQuery) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlQuery constructs the type using only CGO pointers.
+func newQSqlQuery(h *C.QSqlQuery) *QSqlQuery {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlQuery{h: h}
+}
+
+// UnsafeNewQSqlQuery constructs the type using only unsafe pointers.
+func UnsafeNewQSqlQuery(h unsafe.Pointer) *QSqlQuery {
+	return newQSqlQuery((*C.QSqlQuery)(h))
+}
+
+// NewQSqlQuery constructs a new QSqlQuery object.
+func NewQSqlQuery(r *QSqlResult) *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new(r.cPointer()))
+}
+
+// NewQSqlQuery2 constructs a new QSqlQuery object.
+func NewQSqlQuery2() *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new2())
+}
+
+// NewQSqlQuery3 constructs a new QSqlQuery object.
+func NewQSqlQuery3(db QSqlDatabase) *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new3(db.cPointer()))
+}
+
+// NewQSqlQuery4 constructs a new QSqlQuery object.
+func NewQSqlQuery4(other *QSqlQuery) *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new4(other.cPointer()))
+}
+
+// NewQSqlQuery5 constructs a new QSqlQuery object.
+func NewQSqlQuery5(query string) *QSqlQuery {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+
+	return newQSqlQuery(C.QSqlQuery_new5(query_ms))
+}
+
+// NewQSqlQuery6 constructs a new QSqlQuery object.
+func NewQSqlQuery6(query string, db QSqlDatabase) *QSqlQuery {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+
+	return newQSqlQuery(C.QSqlQuery_new6(query_ms, db.cPointer()))
+}
+
+func (this *QSqlQuery) OperatorAssign(other *QSqlQuery) {
+	C.QSqlQuery_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlQuery) IsValid() bool {
+	return (bool)(C.QSqlQuery_isValid(this.h))
+}
+
+func (this *QSqlQuery) IsActive() bool {
+	return (bool)(C.QSqlQuery_isActive(this.h))
+}
+
+func (this *QSqlQuery) IsNull(field int) bool {
+	return (bool)(C.QSqlQuery_isNull(this.h, (C.int)(field)))
+}
+
+func (this *QSqlQuery) IsNullWithName(name string) bool {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (bool)(C.QSqlQuery_isNullWithName(this.h, name_ms))
+}
+
+func (this *QSqlQuery) At() int {
+	return (int)(C.QSqlQuery_at(this.h))
+}
+
+func (this *QSqlQuery) LastQuery() string {
+	var _ms C.struct_miqt_string = C.QSqlQuery_lastQuery(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlQuery) NumRowsAffected() int {
+	return (int)(C.QSqlQuery_numRowsAffected(this.h))
+}
+
+func (this *QSqlQuery) LastError() *QSqlError {
+	_goptr := newQSqlError(C.QSqlQuery_lastError(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) IsSelect() bool {
+	return (bool)(C.QSqlQuery_isSelect(this.h))
+}
+
+func (this *QSqlQuery) Size() int {
+	return (int)(C.QSqlQuery_size(this.h))
+}
+
+func (this *QSqlQuery) Driver() *QSqlDriver {
+	return newQSqlDriver(C.QSqlQuery_driver(this.h))
+}
+
+func (this *QSqlQuery) Result() *QSqlResult {
+	return newQSqlResult(C.QSqlQuery_result(this.h))
+}
+
+func (this *QSqlQuery) IsForwardOnly() bool {
+	return (bool)(C.QSqlQuery_isForwardOnly(this.h))
+}
+
+func (this *QSqlQuery) Record() *QSqlRecord {
+	_goptr := newQSqlRecord(C.QSqlQuery_record(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) SetForwardOnly(forward bool) {
+	C.QSqlQuery_setForwardOnly(this.h, (C.bool)(forward))
+}
+
+func (this *QSqlQuery) Exec(query string) bool {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+	return (bool)(C.QSqlQuery_exec(this.h, query_ms))
+}
+
+func (this *QSqlQuery) Value(i int) *qt.QVariant {
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_value(this.h, (C.int)(i))))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) ValueWithName(name string) *qt.QVariant {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_valueWithName(this.h, name_ms)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) SetNumericalPrecisionPolicy(precisionPolicy QSql__NumericalPrecisionPolicy) {
+	C.QSqlQuery_setNumericalPrecisionPolicy(this.h, (C.int)(precisionPolicy))
+}
+
+func (this *QSqlQuery) NumericalPrecisionPolicy() QSql__NumericalPrecisionPolicy {
+	return (QSql__NumericalPrecisionPolicy)(C.QSqlQuery_numericalPrecisionPolicy(this.h))
+}
+
+func (this *QSqlQuery) Seek(i int) bool {
+	return (bool)(C.QSqlQuery_seek(this.h, (C.int)(i)))
+}
+
+func (this *QSqlQuery) Next() bool {
+	return (bool)(C.QSqlQuery_next(this.h))
+}
+
+func (this *QSqlQuery) Previous() bool {
+	return (bool)(C.QSqlQuery_previous(this.h))
+}
+
+func (this *QSqlQuery) First() bool {
+	return (bool)(C.QSqlQuery_first(this.h))
+}
+
+func (this *QSqlQuery) Last() bool {
+	return (bool)(C.QSqlQuery_last(this.h))
+}
+
+func (this *QSqlQuery) Clear() {
+	C.QSqlQuery_clear(this.h)
+}
+
+func (this *QSqlQuery) Exec2() bool {
+	return (bool)(C.QSqlQuery_exec2(this.h))
+}
+
+func (this *QSqlQuery) ExecBatch() bool {
+	return (bool)(C.QSqlQuery_execBatch(this.h))
+}
+
+func (this *QSqlQuery) Prepare(query string) bool {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+	return (bool)(C.QSqlQuery_prepare(this.h, query_ms))
+}
+
+func (this *QSqlQuery) BindValue(placeholder string, val *qt.QVariant) {
+	placeholder_ms := C.struct_miqt_string{}
+	placeholder_ms.data = C.CString(placeholder)
+	placeholder_ms.len = C.size_t(len(placeholder))
+	defer C.free(unsafe.Pointer(placeholder_ms.data))
+	C.QSqlQuery_bindValue(this.h, placeholder_ms, (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlQuery) BindValue2(pos int, val *qt.QVariant) {
+	C.QSqlQuery_bindValue2(this.h, (C.int)(pos), (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlQuery) AddBindValue(val *qt.QVariant) {
+	C.QSqlQuery_addBindValue(this.h, (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlQuery) BoundValue(placeholder string) *qt.QVariant {
+	placeholder_ms := C.struct_miqt_string{}
+	placeholder_ms.data = C.CString(placeholder)
+	placeholder_ms.len = C.size_t(len(placeholder))
+	defer C.free(unsafe.Pointer(placeholder_ms.data))
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_boundValue(this.h, placeholder_ms)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) BoundValueWithPos(pos int) *qt.QVariant {
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_boundValueWithPos(this.h, (C.int)(pos))))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) BoundValues() map[string]qt.QVariant {
+	var _mm C.struct_miqt_map = C.QSqlQuery_boundValues(this.h)
+	_ret := make(map[string]qt.QVariant, int(_mm.len))
+	_Keys := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_mm.keys))
+	_Values := (*[0xffff]*C.QVariant)(unsafe.Pointer(_mm.values))
+	for i := 0; i < int(_mm.len); i++ {
+		var _mapkey_ms C.struct_miqt_string = _Keys[i]
+		_mapkey_ret := C.GoStringN(_mapkey_ms.data, C.int(int64(_mapkey_ms.len)))
+		C.free(unsafe.Pointer(_mapkey_ms.data))
+		_entry_Key := _mapkey_ret
+		_mapval_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(_Values[i]))
+		_mapval_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+		_entry_Value := *_mapval_goptr
+
+		_ret[_entry_Key] = _entry_Value
+	}
+	return _ret
+}
+
+func (this *QSqlQuery) ExecutedQuery() string {
+	var _ms C.struct_miqt_string = C.QSqlQuery_executedQuery(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlQuery) LastInsertId() *qt.QVariant {
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_lastInsertId(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) Finish() {
+	C.QSqlQuery_finish(this.h)
+}
+
+func (this *QSqlQuery) NextResult() bool {
+	return (bool)(C.QSqlQuery_nextResult(this.h))
+}
+
+func (this *QSqlQuery) Seek2(i int, relative bool) bool {
+	return (bool)(C.QSqlQuery_seek2(this.h, (C.int)(i), (C.bool)(relative)))
+}
+
+func (this *QSqlQuery) ExecBatchWithMode(mode QSqlQuery__BatchExecutionMode) bool {
+	return (bool)(C.QSqlQuery_execBatchWithMode(this.h, (C.int)(mode)))
+}
+
+func (this *QSqlQuery) BindValue3(placeholder string, val *qt.QVariant, typeVal QSql__ParamTypeFlag) {
+	placeholder_ms := C.struct_miqt_string{}
+	placeholder_ms.data = C.CString(placeholder)
+	placeholder_ms.len = C.size_t(len(placeholder))
+	defer C.free(unsafe.Pointer(placeholder_ms.data))
+	C.QSqlQuery_bindValue3(this.h, placeholder_ms, (*C.QVariant)(val.UnsafePointer()), (C.int)(typeVal))
+}
+
+func (this *QSqlQuery) BindValue4(pos int, val *qt.QVariant, typeVal QSql__ParamTypeFlag) {
+	C.QSqlQuery_bindValue4(this.h, (C.int)(pos), (*C.QVariant)(val.UnsafePointer()), (C.int)(typeVal))
+}
+
+func (this *QSqlQuery) AddBindValue2(val *qt.QVariant, typeVal QSql__ParamTypeFlag) {
+	C.QSqlQuery_addBindValue2(this.h, (*C.QVariant)(val.UnsafePointer()), (C.int)(typeVal))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlQuery) Delete() {
+	C.QSqlQuery_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlQuery) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlQuery) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqlquery.h

@@ -0,0 +1,93 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLQUERY_H
+#define MIQT_QT_SQL_GEN_QSQLQUERY_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlDatabase;
+class QSqlDriver;
+class QSqlError;
+class QSqlQuery;
+class QSqlRecord;
+class QSqlResult;
+class QVariant;
+#else
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QSqlResult QSqlResult;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlQuery* QSqlQuery_new(QSqlResult* r);
+QSqlQuery* QSqlQuery_new2();
+QSqlQuery* QSqlQuery_new3(QSqlDatabase* db);
+QSqlQuery* QSqlQuery_new4(QSqlQuery* other);
+QSqlQuery* QSqlQuery_new5(struct miqt_string query);
+QSqlQuery* QSqlQuery_new6(struct miqt_string query, QSqlDatabase* db);
+void QSqlQuery_operatorAssign(QSqlQuery* self, QSqlQuery* other);
+bool QSqlQuery_isValid(const QSqlQuery* self);
+bool QSqlQuery_isActive(const QSqlQuery* self);
+bool QSqlQuery_isNull(const QSqlQuery* self, int field);
+bool QSqlQuery_isNullWithName(const QSqlQuery* self, struct miqt_string name);
+int QSqlQuery_at(const QSqlQuery* self);
+struct miqt_string QSqlQuery_lastQuery(const QSqlQuery* self);
+int QSqlQuery_numRowsAffected(const QSqlQuery* self);
+QSqlError* QSqlQuery_lastError(const QSqlQuery* self);
+bool QSqlQuery_isSelect(const QSqlQuery* self);
+int QSqlQuery_size(const QSqlQuery* self);
+QSqlDriver* QSqlQuery_driver(const QSqlQuery* self);
+QSqlResult* QSqlQuery_result(const QSqlQuery* self);
+bool QSqlQuery_isForwardOnly(const QSqlQuery* self);
+QSqlRecord* QSqlQuery_record(const QSqlQuery* self);
+void QSqlQuery_setForwardOnly(QSqlQuery* self, bool forward);
+bool QSqlQuery_exec(QSqlQuery* self, struct miqt_string query);
+QVariant* QSqlQuery_value(const QSqlQuery* self, int i);
+QVariant* QSqlQuery_valueWithName(const QSqlQuery* self, struct miqt_string name);
+void QSqlQuery_setNumericalPrecisionPolicy(QSqlQuery* self, int precisionPolicy);
+int QSqlQuery_numericalPrecisionPolicy(const QSqlQuery* self);
+bool QSqlQuery_seek(QSqlQuery* self, int i);
+bool QSqlQuery_next(QSqlQuery* self);
+bool QSqlQuery_previous(QSqlQuery* self);
+bool QSqlQuery_first(QSqlQuery* self);
+bool QSqlQuery_last(QSqlQuery* self);
+void QSqlQuery_clear(QSqlQuery* self);
+bool QSqlQuery_exec2(QSqlQuery* self);
+bool QSqlQuery_execBatch(QSqlQuery* self);
+bool QSqlQuery_prepare(QSqlQuery* self, struct miqt_string query);
+void QSqlQuery_bindValue(QSqlQuery* self, struct miqt_string placeholder, QVariant* val);
+void QSqlQuery_bindValue2(QSqlQuery* self, int pos, QVariant* val);
+void QSqlQuery_addBindValue(QSqlQuery* self, QVariant* val);
+QVariant* QSqlQuery_boundValue(const QSqlQuery* self, struct miqt_string placeholder);
+QVariant* QSqlQuery_boundValueWithPos(const QSqlQuery* self, int pos);
+struct miqt_map /* of struct miqt_string to QVariant* */  QSqlQuery_boundValues(const QSqlQuery* self);
+struct miqt_string QSqlQuery_executedQuery(const QSqlQuery* self);
+QVariant* QSqlQuery_lastInsertId(const QSqlQuery* self);
+void QSqlQuery_finish(QSqlQuery* self);
+bool QSqlQuery_nextResult(QSqlQuery* self);
+bool QSqlQuery_seek2(QSqlQuery* self, int i, bool relative);
+bool QSqlQuery_execBatchWithMode(QSqlQuery* self, int mode);
+void QSqlQuery_bindValue3(QSqlQuery* self, struct miqt_string placeholder, QVariant* val, int type);
+void QSqlQuery_bindValue4(QSqlQuery* self, int pos, QVariant* val, int type);
+void QSqlQuery_addBindValue2(QSqlQuery* self, QVariant* val, int type);
+
+void QSqlQuery_delete(QSqlQuery* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlquerymodel.h

@@ -0,0 +1,207 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLQUERYMODEL_H
+#define MIQT_QT_SQL_GEN_QSQLQUERYMODEL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemModel;
+class QAbstractTableModel;
+class QChildEvent;
+class QDataStream;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QMimeData;
+class QModelIndex;
+class QObject;
+class QSize;
+class QSqlDatabase;
+class QSqlError;
+class QSqlQuery;
+class QSqlQueryModel;
+class QSqlRecord;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractTableModel QAbstractTableModel;
+typedef struct QChildEvent QChildEvent;
+typedef struct QDataStream QDataStream;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMimeData QMimeData;
+typedef struct QModelIndex QModelIndex;
+typedef struct QObject QObject;
+typedef struct QSize QSize;
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlQueryModel QSqlQueryModel;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlQueryModel* QSqlQueryModel_new();
+QSqlQueryModel* QSqlQueryModel_new2(QObject* parent);
+void QSqlQueryModel_virtbase(QSqlQueryModel* src, QAbstractTableModel** outptr_QAbstractTableModel);
+QMetaObject* QSqlQueryModel_metaObject(const QSqlQueryModel* self);
+void* QSqlQueryModel_metacast(QSqlQueryModel* self, const char* param1);
+struct miqt_string QSqlQueryModel_tr(const char* s);
+struct miqt_string QSqlQueryModel_trUtf8(const char* s);
+int QSqlQueryModel_rowCount(const QSqlQueryModel* self, QModelIndex* parent);
+int QSqlQueryModel_columnCount(const QSqlQueryModel* self, QModelIndex* parent);
+QSqlRecord* QSqlQueryModel_record(const QSqlQueryModel* self, int row);
+QSqlRecord* QSqlQueryModel_record2(const QSqlQueryModel* self);
+QVariant* QSqlQueryModel_data(const QSqlQueryModel* self, QModelIndex* item, int role);
+QVariant* QSqlQueryModel_headerData(const QSqlQueryModel* self, int section, int orientation, int role);
+bool QSqlQueryModel_setHeaderData(QSqlQueryModel* self, int section, int orientation, QVariant* value, int role);
+bool QSqlQueryModel_insertColumns(QSqlQueryModel* self, int column, int count, QModelIndex* parent);
+bool QSqlQueryModel_removeColumns(QSqlQueryModel* self, int column, int count, QModelIndex* parent);
+void QSqlQueryModel_setQuery(QSqlQueryModel* self, QSqlQuery* query);
+void QSqlQueryModel_setQueryWithQuery(QSqlQueryModel* self, struct miqt_string query);
+QSqlQuery* QSqlQueryModel_query(const QSqlQueryModel* self);
+void QSqlQueryModel_clear(QSqlQueryModel* self);
+QSqlError* QSqlQueryModel_lastError(const QSqlQueryModel* self);
+void QSqlQueryModel_fetchMore(QSqlQueryModel* self, QModelIndex* parent);
+bool QSqlQueryModel_canFetchMore(const QSqlQueryModel* self, QModelIndex* parent);
+struct miqt_map /* of int to struct miqt_string */  QSqlQueryModel_roleNames(const QSqlQueryModel* self);
+void QSqlQueryModel_queryChange(QSqlQueryModel* self);
+QModelIndex* QSqlQueryModel_indexInQuery(const QSqlQueryModel* self, QModelIndex* item);
+struct miqt_string QSqlQueryModel_tr2(const char* s, const char* c);
+struct miqt_string QSqlQueryModel_tr3(const char* s, const char* c, int n);
+struct miqt_string QSqlQueryModel_trUtf82(const char* s, const char* c);
+struct miqt_string QSqlQueryModel_trUtf83(const char* s, const char* c, int n);
+void QSqlQueryModel_setQuery2(QSqlQueryModel* self, struct miqt_string query, QSqlDatabase* db);
+
+bool QSqlQueryModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_columnCount(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_columnCount(const void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QSqlQueryModel_virtualbase_data(const void* self, QModelIndex* item, int role);
+bool QSqlQueryModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QSqlQueryModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QSqlQueryModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QSqlQueryModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_clear(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_clear(void* self);
+bool QSqlQueryModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QSqlQueryModel_virtualbase_roleNames(const void* self);
+bool QSqlQueryModel_override_virtual_queryChange(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_queryChange(void* self);
+bool QSqlQueryModel_override_virtual_indexInQuery(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_indexInQuery(const void* self, QModelIndex* item);
+bool QSqlQueryModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QSqlQueryModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_flags(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_setData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role);
+bool QSqlQueryModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QSqlQueryModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QSqlQueryModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlQueryModel_virtualbase_mimeTypes(const void* self);
+bool QSqlQueryModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QSqlQueryModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QSqlQueryModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_supportedDropActions(const void* self);
+bool QSqlQueryModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_supportedDragActions(const void* self);
+bool QSqlQueryModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlQueryModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlQueryModel_override_virtual_sort(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_sort(void* self, int column, int order);
+bool QSqlQueryModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QSqlQueryModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QSqlQueryModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QSqlQueryModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_submit(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_submit(void* self);
+bool QSqlQueryModel_override_virtual_revert(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_revert(void* self);
+bool QSqlQueryModel_override_virtual_event(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_event(void* self, QEvent* event);
+bool QSqlQueryModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlQueryModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlQueryModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlQueryModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlQueryModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlQueryModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QSqlQueryModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_setLastError(bool* _dynamic_cast_ok, void* self, QSqlError* error);
+void QSqlQueryModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self);
+QModelIndex* QSqlQueryModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+void QSqlQueryModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QSqlQueryModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+bool QSqlQueryModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QSqlQueryModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+bool QSqlQueryModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QSqlQueryModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QSqlQueryModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QSqlQueryModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QObject* QSqlQueryModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlQueryModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlQueryModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlQueryModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlQueryModel_delete(QSqlQueryModel* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlrecord.cpp

@@ -0,0 +1,161 @@
+#include <QSqlField>
+#include <QSqlRecord>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QVariant>
+#include <qsqlrecord.h>
+#include "gen_qsqlrecord.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlRecord* QSqlRecord_new() {
+	return new (std::nothrow) QSqlRecord();
+}
+
+QSqlRecord* QSqlRecord_new2(QSqlRecord* other) {
+	return new (std::nothrow) QSqlRecord(*other);
+}
+
+void QSqlRecord_operatorAssign(QSqlRecord* self, QSqlRecord* other) {
+	self->operator=(*other);
+}
+
+bool QSqlRecord_operatorEqual(const QSqlRecord* self, QSqlRecord* other) {
+	return (*self == *other);
+}
+
+bool QSqlRecord_operatorNotEqual(const QSqlRecord* self, QSqlRecord* other) {
+	return (*self != *other);
+}
+
+QVariant* QSqlRecord_value(const QSqlRecord* self, int i) {
+	return new QVariant(self->value(static_cast<int>(i)));
+}
+
+QVariant* QSqlRecord_valueWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new QVariant(self->value(name_QString));
+}
+
+void QSqlRecord_setValue(QSqlRecord* self, int i, QVariant* val) {
+	self->setValue(static_cast<int>(i), *val);
+}
+
+void QSqlRecord_setValue2(QSqlRecord* self, struct miqt_string name, QVariant* val) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setValue(name_QString, *val);
+}
+
+void QSqlRecord_setNull(QSqlRecord* self, int i) {
+	self->setNull(static_cast<int>(i));
+}
+
+void QSqlRecord_setNullWithName(QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setNull(name_QString);
+}
+
+bool QSqlRecord_isNull(const QSqlRecord* self, int i) {
+	return self->isNull(static_cast<int>(i));
+}
+
+bool QSqlRecord_isNullWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->isNull(name_QString);
+}
+
+int QSqlRecord_indexOf(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->indexOf(name_QString);
+}
+
+struct miqt_string QSqlRecord_fieldName(const QSqlRecord* self, int i) {
+	QString _ret = self->fieldName(static_cast<int>(i));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QSqlField* QSqlRecord_field(const QSqlRecord* self, int i) {
+	return new QSqlField(self->field(static_cast<int>(i)));
+}
+
+QSqlField* QSqlRecord_fieldWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new QSqlField(self->field(name_QString));
+}
+
+bool QSqlRecord_isGenerated(const QSqlRecord* self, int i) {
+	return self->isGenerated(static_cast<int>(i));
+}
+
+bool QSqlRecord_isGeneratedWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->isGenerated(name_QString);
+}
+
+void QSqlRecord_setGenerated(QSqlRecord* self, struct miqt_string name, bool generated) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setGenerated(name_QString, generated);
+}
+
+void QSqlRecord_setGenerated2(QSqlRecord* self, int i, bool generated) {
+	self->setGenerated(static_cast<int>(i), generated);
+}
+
+void QSqlRecord_append(QSqlRecord* self, QSqlField* field) {
+	self->append(*field);
+}
+
+void QSqlRecord_replace(QSqlRecord* self, int pos, QSqlField* field) {
+	self->replace(static_cast<int>(pos), *field);
+}
+
+void QSqlRecord_insert(QSqlRecord* self, int pos, QSqlField* field) {
+	self->insert(static_cast<int>(pos), *field);
+}
+
+void QSqlRecord_remove(QSqlRecord* self, int pos) {
+	self->remove(static_cast<int>(pos));
+}
+
+bool QSqlRecord_isEmpty(const QSqlRecord* self) {
+	return self->isEmpty();
+}
+
+bool QSqlRecord_contains(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->contains(name_QString);
+}
+
+void QSqlRecord_clear(QSqlRecord* self) {
+	self->clear();
+}
+
+void QSqlRecord_clearValues(QSqlRecord* self) {
+	self->clearValues();
+}
+
+int QSqlRecord_count(const QSqlRecord* self) {
+	return self->count();
+}
+
+QSqlRecord* QSqlRecord_keyValues(const QSqlRecord* self, QSqlRecord* keyFields) {
+	return new QSqlRecord(self->keyValues(*keyFields));
+}
+
+void QSqlRecord_delete(QSqlRecord* self) {
+	delete self;
+}
+

qt/sql/gen_qsqlrecord.go

@@ -0,0 +1,238 @@
+package sql
+
+/*
+
+#include "gen_qsqlrecord.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt"
+	"runtime"
+	"unsafe"
+)
+
+type QSqlRecord struct {
+	h *C.QSqlRecord
+}
+
+func (this *QSqlRecord) cPointer() *C.QSqlRecord {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlRecord) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlRecord constructs the type using only CGO pointers.
+func newQSqlRecord(h *C.QSqlRecord) *QSqlRecord {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlRecord{h: h}
+}
+
+// UnsafeNewQSqlRecord constructs the type using only unsafe pointers.
+func UnsafeNewQSqlRecord(h unsafe.Pointer) *QSqlRecord {
+	return newQSqlRecord((*C.QSqlRecord)(h))
+}
+
+// NewQSqlRecord constructs a new QSqlRecord object.
+func NewQSqlRecord() *QSqlRecord {
+
+	return newQSqlRecord(C.QSqlRecord_new())
+}
+
+// NewQSqlRecord2 constructs a new QSqlRecord object.
+func NewQSqlRecord2(other *QSqlRecord) *QSqlRecord {
+
+	return newQSqlRecord(C.QSqlRecord_new2(other.cPointer()))
+}
+
+func (this *QSqlRecord) OperatorAssign(other *QSqlRecord) {
+	C.QSqlRecord_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlRecord) OperatorEqual(other *QSqlRecord) bool {
+	return (bool)(C.QSqlRecord_operatorEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlRecord) OperatorNotEqual(other *QSqlRecord) bool {
+	return (bool)(C.QSqlRecord_operatorNotEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlRecord) Value(i int) *qt.QVariant {
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlRecord_value(this.h, (C.int)(i))))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlRecord) ValueWithName(name string) *qt.QVariant {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlRecord_valueWithName(this.h, name_ms)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlRecord) SetValue(i int, val *qt.QVariant) {
+	C.QSqlRecord_setValue(this.h, (C.int)(i), (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlRecord) SetValue2(name string, val *qt.QVariant) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlRecord_setValue2(this.h, name_ms, (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlRecord) SetNull(i int) {
+	C.QSqlRecord_setNull(this.h, (C.int)(i))
+}
+
+func (this *QSqlRecord) SetNullWithName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlRecord_setNullWithName(this.h, name_ms)
+}
+
+func (this *QSqlRecord) IsNull(i int) bool {
+	return (bool)(C.QSqlRecord_isNull(this.h, (C.int)(i)))
+}
+
+func (this *QSqlRecord) IsNullWithName(name string) bool {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (bool)(C.QSqlRecord_isNullWithName(this.h, name_ms))
+}
+
+func (this *QSqlRecord) IndexOf(name string) int {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (int)(C.QSqlRecord_indexOf(this.h, name_ms))
+}
+
+func (this *QSqlRecord) FieldName(i int) string {
+	var _ms C.struct_miqt_string = C.QSqlRecord_fieldName(this.h, (C.int)(i))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlRecord) Field(i int) *QSqlField {
+	_goptr := newQSqlField(C.QSqlRecord_field(this.h, (C.int)(i)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlRecord) FieldWithName(name string) *QSqlField {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	_goptr := newQSqlField(C.QSqlRecord_fieldWithName(this.h, name_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlRecord) IsGenerated(i int) bool {
+	return (bool)(C.QSqlRecord_isGenerated(this.h, (C.int)(i)))
+}
+
+func (this *QSqlRecord) IsGeneratedWithName(name string) bool {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (bool)(C.QSqlRecord_isGeneratedWithName(this.h, name_ms))
+}
+
+func (this *QSqlRecord) SetGenerated(name string, generated bool) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlRecord_setGenerated(this.h, name_ms, (C.bool)(generated))
+}
+
+func (this *QSqlRecord) SetGenerated2(i int, generated bool) {
+	C.QSqlRecord_setGenerated2(this.h, (C.int)(i), (C.bool)(generated))
+}
+
+func (this *QSqlRecord) Append(field *QSqlField) {
+	C.QSqlRecord_append(this.h, field.cPointer())
+}
+
+func (this *QSqlRecord) Replace(pos int, field *QSqlField) {
+	C.QSqlRecord_replace(this.h, (C.int)(pos), field.cPointer())
+}
+
+func (this *QSqlRecord) Insert(pos int, field *QSqlField) {
+	C.QSqlRecord_insert(this.h, (C.int)(pos), field.cPointer())
+}
+
+func (this *QSqlRecord) Remove(pos int) {
+	C.QSqlRecord_remove(this.h, (C.int)(pos))
+}
+
+func (this *QSqlRecord) IsEmpty() bool {
+	return (bool)(C.QSqlRecord_isEmpty(this.h))
+}
+
+func (this *QSqlRecord) Contains(name string) bool {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (bool)(C.QSqlRecord_contains(this.h, name_ms))
+}
+
+func (this *QSqlRecord) Clear() {
+	C.QSqlRecord_clear(this.h)
+}
+
+func (this *QSqlRecord) ClearValues() {
+	C.QSqlRecord_clearValues(this.h)
+}
+
+func (this *QSqlRecord) Count() int {
+	return (int)(C.QSqlRecord_count(this.h))
+}
+
+func (this *QSqlRecord) KeyValues(keyFields *QSqlRecord) *QSqlRecord {
+	_goptr := newQSqlRecord(C.QSqlRecord_keyValues(this.h, keyFields.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlRecord) Delete() {
+	C.QSqlRecord_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlRecord) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlRecord) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqlrecord.h

@@ -0,0 +1,65 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLRECORD_H
+#define MIQT_QT_SQL_GEN_QSQLRECORD_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlField;
+class QSqlRecord;
+class QVariant;
+#else
+typedef struct QSqlField QSqlField;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlRecord* QSqlRecord_new();
+QSqlRecord* QSqlRecord_new2(QSqlRecord* other);
+void QSqlRecord_operatorAssign(QSqlRecord* self, QSqlRecord* other);
+bool QSqlRecord_operatorEqual(const QSqlRecord* self, QSqlRecord* other);
+bool QSqlRecord_operatorNotEqual(const QSqlRecord* self, QSqlRecord* other);
+QVariant* QSqlRecord_value(const QSqlRecord* self, int i);
+QVariant* QSqlRecord_valueWithName(const QSqlRecord* self, struct miqt_string name);
+void QSqlRecord_setValue(QSqlRecord* self, int i, QVariant* val);
+void QSqlRecord_setValue2(QSqlRecord* self, struct miqt_string name, QVariant* val);
+void QSqlRecord_setNull(QSqlRecord* self, int i);
+void QSqlRecord_setNullWithName(QSqlRecord* self, struct miqt_string name);
+bool QSqlRecord_isNull(const QSqlRecord* self, int i);
+bool QSqlRecord_isNullWithName(const QSqlRecord* self, struct miqt_string name);
+int QSqlRecord_indexOf(const QSqlRecord* self, struct miqt_string name);
+struct miqt_string QSqlRecord_fieldName(const QSqlRecord* self, int i);
+QSqlField* QSqlRecord_field(const QSqlRecord* self, int i);
+QSqlField* QSqlRecord_fieldWithName(const QSqlRecord* self, struct miqt_string name);
+bool QSqlRecord_isGenerated(const QSqlRecord* self, int i);
+bool QSqlRecord_isGeneratedWithName(const QSqlRecord* self, struct miqt_string name);
+void QSqlRecord_setGenerated(QSqlRecord* self, struct miqt_string name, bool generated);
+void QSqlRecord_setGenerated2(QSqlRecord* self, int i, bool generated);
+void QSqlRecord_append(QSqlRecord* self, QSqlField* field);
+void QSqlRecord_replace(QSqlRecord* self, int pos, QSqlField* field);
+void QSqlRecord_insert(QSqlRecord* self, int pos, QSqlField* field);
+void QSqlRecord_remove(QSqlRecord* self, int pos);
+bool QSqlRecord_isEmpty(const QSqlRecord* self);
+bool QSqlRecord_contains(const QSqlRecord* self, struct miqt_string name);
+void QSqlRecord_clear(QSqlRecord* self);
+void QSqlRecord_clearValues(QSqlRecord* self);
+int QSqlRecord_count(const QSqlRecord* self);
+QSqlRecord* QSqlRecord_keyValues(const QSqlRecord* self, QSqlRecord* keyFields);
+
+void QSqlRecord_delete(QSqlRecord* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlrelationaltablemodel.h

@@ -0,0 +1,253 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLRELATIONALTABLEMODEL_H
+#define MIQT_QT_SQL_GEN_QSQLRELATIONALTABLEMODEL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemModel;
+class QAbstractTableModel;
+class QChildEvent;
+class QDataStream;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QMimeData;
+class QModelIndex;
+class QObject;
+class QSize;
+class QSqlDatabase;
+class QSqlError;
+class QSqlIndex;
+class QSqlQuery;
+class QSqlQueryModel;
+class QSqlRecord;
+class QSqlRelation;
+class QSqlRelationalTableModel;
+class QSqlTableModel;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractTableModel QAbstractTableModel;
+typedef struct QChildEvent QChildEvent;
+typedef struct QDataStream QDataStream;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMimeData QMimeData;
+typedef struct QModelIndex QModelIndex;
+typedef struct QObject QObject;
+typedef struct QSize QSize;
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlQueryModel QSqlQueryModel;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QSqlRelation QSqlRelation;
+typedef struct QSqlRelationalTableModel QSqlRelationalTableModel;
+typedef struct QSqlTableModel QSqlTableModel;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlRelation* QSqlRelation_new();
+QSqlRelation* QSqlRelation_new2(struct miqt_string aTableName, struct miqt_string indexCol, struct miqt_string displayCol);
+QSqlRelation* QSqlRelation_new3(QSqlRelation* param1);
+void QSqlRelation_swap(QSqlRelation* self, QSqlRelation* other);
+struct miqt_string QSqlRelation_tableName(const QSqlRelation* self);
+struct miqt_string QSqlRelation_indexColumn(const QSqlRelation* self);
+struct miqt_string QSqlRelation_displayColumn(const QSqlRelation* self);
+bool QSqlRelation_isValid(const QSqlRelation* self);
+
+void QSqlRelation_delete(QSqlRelation* self);
+
+QSqlRelationalTableModel* QSqlRelationalTableModel_new();
+QSqlRelationalTableModel* QSqlRelationalTableModel_new2(QObject* parent);
+QSqlRelationalTableModel* QSqlRelationalTableModel_new3(QObject* parent, QSqlDatabase* db);
+void QSqlRelationalTableModel_virtbase(QSqlRelationalTableModel* src, QSqlTableModel** outptr_QSqlTableModel);
+QMetaObject* QSqlRelationalTableModel_metaObject(const QSqlRelationalTableModel* self);
+void* QSqlRelationalTableModel_metacast(QSqlRelationalTableModel* self, const char* param1);
+struct miqt_string QSqlRelationalTableModel_tr(const char* s);
+struct miqt_string QSqlRelationalTableModel_trUtf8(const char* s);
+QVariant* QSqlRelationalTableModel_data(const QSqlRelationalTableModel* self, QModelIndex* item, int role);
+bool QSqlRelationalTableModel_setData(QSqlRelationalTableModel* self, QModelIndex* item, QVariant* value, int role);
+bool QSqlRelationalTableModel_removeColumns(QSqlRelationalTableModel* self, int column, int count, QModelIndex* parent);
+void QSqlRelationalTableModel_clear(QSqlRelationalTableModel* self);
+bool QSqlRelationalTableModel_select(QSqlRelationalTableModel* self);
+void QSqlRelationalTableModel_setTable(QSqlRelationalTableModel* self, struct miqt_string tableName);
+void QSqlRelationalTableModel_setRelation(QSqlRelationalTableModel* self, int column, QSqlRelation* relation);
+QSqlRelation* QSqlRelationalTableModel_relation(const QSqlRelationalTableModel* self, int column);
+QSqlTableModel* QSqlRelationalTableModel_relationModel(const QSqlRelationalTableModel* self, int column);
+void QSqlRelationalTableModel_setJoinMode(QSqlRelationalTableModel* self, int joinMode);
+void QSqlRelationalTableModel_revertRow(QSqlRelationalTableModel* self, int row);
+struct miqt_string QSqlRelationalTableModel_selectStatement(const QSqlRelationalTableModel* self);
+bool QSqlRelationalTableModel_updateRowInTable(QSqlRelationalTableModel* self, int row, QSqlRecord* values);
+bool QSqlRelationalTableModel_insertRowIntoTable(QSqlRelationalTableModel* self, QSqlRecord* values);
+struct miqt_string QSqlRelationalTableModel_orderByClause(const QSqlRelationalTableModel* self);
+struct miqt_string QSqlRelationalTableModel_tr2(const char* s, const char* c);
+struct miqt_string QSqlRelationalTableModel_tr3(const char* s, const char* c, int n);
+struct miqt_string QSqlRelationalTableModel_trUtf82(const char* s, const char* c);
+struct miqt_string QSqlRelationalTableModel_trUtf83(const char* s, const char* c, int n);
+
+bool QSqlRelationalTableModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QSqlRelationalTableModel_virtualbase_data(const void* self, QModelIndex* item, int role);
+bool QSqlRelationalTableModel_override_virtual_setData(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_setData(void* self, QModelIndex* item, QVariant* value, int role);
+bool QSqlRelationalTableModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_clear(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_clear(void* self);
+bool QSqlRelationalTableModel_override_virtual_select(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_select(void* self);
+bool QSqlRelationalTableModel_override_virtual_setTable(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_setTable(void* self, struct miqt_string tableName);
+bool QSqlRelationalTableModel_override_virtual_setRelation(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_setRelation(void* self, int column, QSqlRelation* relation);
+bool QSqlRelationalTableModel_override_virtual_relationModel(void* self, intptr_t slot);
+QSqlTableModel* QSqlRelationalTableModel_virtualbase_relationModel(const void* self, int column);
+bool QSqlRelationalTableModel_override_virtual_revertRow(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_revertRow(void* self, int row);
+bool QSqlRelationalTableModel_override_virtual_selectStatement(void* self, intptr_t slot);
+struct miqt_string QSqlRelationalTableModel_virtualbase_selectStatement(const void* self);
+bool QSqlRelationalTableModel_override_virtual_updateRowInTable(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_updateRowInTable(void* self, int row, QSqlRecord* values);
+bool QSqlRelationalTableModel_override_virtual_insertRowIntoTable(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_insertRowIntoTable(void* self, QSqlRecord* values);
+bool QSqlRelationalTableModel_override_virtual_orderByClause(void* self, intptr_t slot);
+struct miqt_string QSqlRelationalTableModel_virtualbase_orderByClause(const void* self);
+bool QSqlRelationalTableModel_override_virtual_flags(void* self, intptr_t slot);
+int QSqlRelationalTableModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QSqlRelationalTableModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QSqlRelationalTableModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QSqlRelationalTableModel_override_virtual_setEditStrategy(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_setEditStrategy(void* self, int strategy);
+bool QSqlRelationalTableModel_override_virtual_sort(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_sort(void* self, int column, int order);
+bool QSqlRelationalTableModel_override_virtual_setSort(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_setSort(void* self, int column, int order);
+bool QSqlRelationalTableModel_override_virtual_setFilter(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_setFilter(void* self, struct miqt_string filter);
+bool QSqlRelationalTableModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QSqlRelationalTableModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_selectRow(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_selectRow(void* self, int row);
+bool QSqlRelationalTableModel_override_virtual_submit(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_submit(void* self);
+bool QSqlRelationalTableModel_override_virtual_revert(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_revert(void* self);
+bool QSqlRelationalTableModel_override_virtual_deleteRowFromTable(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_deleteRowFromTable(void* self, int row);
+bool QSqlRelationalTableModel_override_virtual_indexInQuery(void* self, intptr_t slot);
+QModelIndex* QSqlRelationalTableModel_virtualbase_indexInQuery(const void* self, QModelIndex* item);
+bool QSqlRelationalTableModel_override_virtual_columnCount(void* self, intptr_t slot);
+int QSqlRelationalTableModel_virtualbase_columnCount(const void* self, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QSqlRelationalTableModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QSqlRelationalTableModel_virtualbase_roleNames(const void* self);
+bool QSqlRelationalTableModel_override_virtual_queryChange(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_queryChange(void* self);
+bool QSqlRelationalTableModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QSqlRelationalTableModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QSqlRelationalTableModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QSqlRelationalTableModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QSqlRelationalTableModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QSqlRelationalTableModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QSqlRelationalTableModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlRelationalTableModel_virtualbase_mimeTypes(const void* self);
+bool QSqlRelationalTableModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QSqlRelationalTableModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QSqlRelationalTableModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlRelationalTableModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QSqlRelationalTableModel_virtualbase_supportedDropActions(const void* self);
+bool QSqlRelationalTableModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QSqlRelationalTableModel_virtualbase_supportedDragActions(const void* self);
+bool QSqlRelationalTableModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlRelationalTableModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlRelationalTableModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QSqlRelationalTableModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QSqlRelationalTableModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QSqlRelationalTableModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QSqlRelationalTableModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QSqlRelationalTableModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QSqlRelationalTableModel_override_virtual_event(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_event(void* self, QEvent* event);
+bool QSqlRelationalTableModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlRelationalTableModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlRelationalTableModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlRelationalTableModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlRelationalTableModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlRelationalTableModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlRelationalTableModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlRelationalTableModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QSqlRelationalTableModel_protectedbase_setPrimaryKey(bool* _dynamic_cast_ok, void* self, QSqlIndex* key);
+void QSqlRelationalTableModel_protectedbase_setQuery(bool* _dynamic_cast_ok, void* self, QSqlQuery* query);
+QSqlRecord* QSqlRelationalTableModel_protectedbase_primaryValues(bool* _dynamic_cast_ok, const void* self, int row);
+void QSqlRelationalTableModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlRelationalTableModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QSqlRelationalTableModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlRelationalTableModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+void QSqlRelationalTableModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlRelationalTableModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlRelationalTableModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlRelationalTableModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlRelationalTableModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlRelationalTableModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlRelationalTableModel_protectedbase_setLastError(bool* _dynamic_cast_ok, void* self, QSqlError* error);
+void QSqlRelationalTableModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self);
+QModelIndex* QSqlRelationalTableModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+void QSqlRelationalTableModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QSqlRelationalTableModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+bool QSqlRelationalTableModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QSqlRelationalTableModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+bool QSqlRelationalTableModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QSqlRelationalTableModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlRelationalTableModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QSqlRelationalTableModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QSqlRelationalTableModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QObject* QSqlRelationalTableModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlRelationalTableModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlRelationalTableModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlRelationalTableModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlRelationalTableModel_delete(QSqlRelationalTableModel* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqlresult.cpp

@@ -0,0 +1,28 @@
+#include <QSqlDriver>
+#include <QSqlError>
+#include <QSqlRecord>
+#include <QSqlResult>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QVariant>
+#include <QVector>
+#include <qsqlresult.h>
+#include "gen_qsqlresult.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QVariant* QSqlResult_handle(const QSqlResult* self) {
+	return new QVariant(self->handle());
+}
+
+void QSqlResult_delete(QSqlResult* self) {
+	delete self;
+}
+

qt/sql/gen_qsqlresult.go

@@ -0,0 +1,74 @@
+package sql
+
+/*
+
+#include "gen_qsqlresult.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt"
+	"runtime"
+	"unsafe"
+)
+
+type QSqlResult__BindingSyntax int
+
+const (
+	QSqlResult__PositionalBinding QSqlResult__BindingSyntax = 0
+	QSqlResult__NamedBinding      QSqlResult__BindingSyntax = 1
+)
+
+type QSqlResult struct {
+	h *C.QSqlResult
+}
+
+func (this *QSqlResult) cPointer() *C.QSqlResult {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlResult) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlResult constructs the type using only CGO pointers.
+func newQSqlResult(h *C.QSqlResult) *QSqlResult {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlResult{h: h}
+}
+
+// UnsafeNewQSqlResult constructs the type using only unsafe pointers.
+func UnsafeNewQSqlResult(h unsafe.Pointer) *QSqlResult {
+	return newQSqlResult((*C.QSqlResult)(h))
+}
+
+func (this *QSqlResult) Handle() *qt.QVariant {
+	_goptr := qt.UnsafeNewQVariant(unsafe.Pointer(C.QSqlResult_handle(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlResult) Delete() {
+	C.QSqlResult_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlResult) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlResult) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt/sql/gen_qsqlresult.h

@@ -0,0 +1,67 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLRESULT_H
+#define MIQT_QT_SQL_GEN_QSQLRESULT_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlDriver;
+class QSqlError;
+class QSqlRecord;
+class QSqlResult;
+class QVariant;
+#else
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QSqlResult QSqlResult;
+typedef struct QVariant QVariant;
+#endif
+
+QVariant* QSqlResult_handle(const QSqlResult* self);
+void QSqlResult_setAt(QSqlResult* self, int at);
+void QSqlResult_setActive(QSqlResult* self, bool a);
+void QSqlResult_setLastError(QSqlResult* self, QSqlError* e);
+void QSqlResult_setQuery(QSqlResult* self, struct miqt_string query);
+void QSqlResult_setSelect(QSqlResult* self, bool s);
+void QSqlResult_setForwardOnly(QSqlResult* self, bool forward);
+bool QSqlResult_exec(QSqlResult* self);
+bool QSqlResult_prepare(QSqlResult* self, struct miqt_string query);
+bool QSqlResult_savePrepare(QSqlResult* self, struct miqt_string sqlquery);
+void QSqlResult_bindValue(QSqlResult* self, int pos, QVariant* val, int type);
+void QSqlResult_bindValue2(QSqlResult* self, struct miqt_string placeholder, QVariant* val, int type);
+QVariant* QSqlResult_data(QSqlResult* self, int i);
+bool QSqlResult_isNull(QSqlResult* self, int i);
+bool QSqlResult_reset(QSqlResult* self, struct miqt_string sqlquery);
+bool QSqlResult_fetch(QSqlResult* self, int i);
+bool QSqlResult_fetchNext(QSqlResult* self);
+bool QSqlResult_fetchPrevious(QSqlResult* self);
+bool QSqlResult_fetchFirst(QSqlResult* self);
+bool QSqlResult_fetchLast(QSqlResult* self);
+int QSqlResult_size(QSqlResult* self);
+int QSqlResult_numRowsAffected(QSqlResult* self);
+QSqlRecord* QSqlResult_record(const QSqlResult* self);
+QVariant* QSqlResult_lastInsertId(const QSqlResult* self);
+void QSqlResult_virtualHook(QSqlResult* self, int id, void* data);
+bool QSqlResult_execBatch(QSqlResult* self, bool arrayBind);
+void QSqlResult_detachFromResultSet(QSqlResult* self);
+void QSqlResult_setNumericalPrecisionPolicy(QSqlResult* self, int policy);
+bool QSqlResult_nextResult(QSqlResult* self);
+
+void QSqlResult_delete(QSqlResult* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qsqltablemodel.h

@@ -0,0 +1,266 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QSQLTABLEMODEL_H
+#define MIQT_QT_SQL_GEN_QSQLTABLEMODEL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemModel;
+class QAbstractTableModel;
+class QChildEvent;
+class QDataStream;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QMimeData;
+class QModelIndex;
+class QObject;
+class QSize;
+class QSqlDatabase;
+class QSqlError;
+class QSqlIndex;
+class QSqlQuery;
+class QSqlQueryModel;
+class QSqlRecord;
+class QSqlTableModel;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractTableModel QAbstractTableModel;
+typedef struct QChildEvent QChildEvent;
+typedef struct QDataStream QDataStream;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMimeData QMimeData;
+typedef struct QModelIndex QModelIndex;
+typedef struct QObject QObject;
+typedef struct QSize QSize;
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlQueryModel QSqlQueryModel;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QSqlTableModel QSqlTableModel;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlTableModel* QSqlTableModel_new();
+QSqlTableModel* QSqlTableModel_new2(QObject* parent);
+QSqlTableModel* QSqlTableModel_new3(QObject* parent, QSqlDatabase* db);
+void QSqlTableModel_virtbase(QSqlTableModel* src, QSqlQueryModel** outptr_QSqlQueryModel);
+QMetaObject* QSqlTableModel_metaObject(const QSqlTableModel* self);
+void* QSqlTableModel_metacast(QSqlTableModel* self, const char* param1);
+struct miqt_string QSqlTableModel_tr(const char* s);
+struct miqt_string QSqlTableModel_trUtf8(const char* s);
+void QSqlTableModel_setTable(QSqlTableModel* self, struct miqt_string tableName);
+struct miqt_string QSqlTableModel_tableName(const QSqlTableModel* self);
+int QSqlTableModel_flags(const QSqlTableModel* self, QModelIndex* index);
+QSqlRecord* QSqlTableModel_record(const QSqlTableModel* self);
+QSqlRecord* QSqlTableModel_recordWithRow(const QSqlTableModel* self, int row);
+QVariant* QSqlTableModel_data(const QSqlTableModel* self, QModelIndex* idx, int role);
+bool QSqlTableModel_setData(QSqlTableModel* self, QModelIndex* index, QVariant* value, int role);
+QVariant* QSqlTableModel_headerData(const QSqlTableModel* self, int section, int orientation, int role);
+bool QSqlTableModel_isDirty(const QSqlTableModel* self);
+bool QSqlTableModel_isDirtyWithIndex(const QSqlTableModel* self, QModelIndex* index);
+void QSqlTableModel_clear(QSqlTableModel* self);
+void QSqlTableModel_setEditStrategy(QSqlTableModel* self, int strategy);
+int QSqlTableModel_editStrategy(const QSqlTableModel* self);
+QSqlIndex* QSqlTableModel_primaryKey(const QSqlTableModel* self);
+QSqlDatabase* QSqlTableModel_database(const QSqlTableModel* self);
+int QSqlTableModel_fieldIndex(const QSqlTableModel* self, struct miqt_string fieldName);
+void QSqlTableModel_sort(QSqlTableModel* self, int column, int order);
+void QSqlTableModel_setSort(QSqlTableModel* self, int column, int order);
+struct miqt_string QSqlTableModel_filter(const QSqlTableModel* self);
+void QSqlTableModel_setFilter(QSqlTableModel* self, struct miqt_string filter);
+int QSqlTableModel_rowCount(const QSqlTableModel* self, QModelIndex* parent);
+bool QSqlTableModel_removeColumns(QSqlTableModel* self, int column, int count, QModelIndex* parent);
+bool QSqlTableModel_removeRows(QSqlTableModel* self, int row, int count, QModelIndex* parent);
+bool QSqlTableModel_insertRows(QSqlTableModel* self, int row, int count, QModelIndex* parent);
+bool QSqlTableModel_insertRecord(QSqlTableModel* self, int row, QSqlRecord* record);
+bool QSqlTableModel_setRecord(QSqlTableModel* self, int row, QSqlRecord* record);
+void QSqlTableModel_revertRow(QSqlTableModel* self, int row);
+bool QSqlTableModel_select(QSqlTableModel* self);
+bool QSqlTableModel_selectRow(QSqlTableModel* self, int row);
+bool QSqlTableModel_submit(QSqlTableModel* self);
+void QSqlTableModel_revert(QSqlTableModel* self);
+bool QSqlTableModel_submitAll(QSqlTableModel* self);
+void QSqlTableModel_revertAll(QSqlTableModel* self);
+void QSqlTableModel_primeInsert(QSqlTableModel* self, int row, QSqlRecord* record);
+void QSqlTableModel_connect_primeInsert(QSqlTableModel* self, intptr_t slot);
+void QSqlTableModel_beforeInsert(QSqlTableModel* self, QSqlRecord* record);
+void QSqlTableModel_connect_beforeInsert(QSqlTableModel* self, intptr_t slot);
+void QSqlTableModel_beforeUpdate(QSqlTableModel* self, int row, QSqlRecord* record);
+void QSqlTableModel_connect_beforeUpdate(QSqlTableModel* self, intptr_t slot);
+void QSqlTableModel_beforeDelete(QSqlTableModel* self, int row);
+void QSqlTableModel_connect_beforeDelete(QSqlTableModel* self, intptr_t slot);
+bool QSqlTableModel_updateRowInTable(QSqlTableModel* self, int row, QSqlRecord* values);
+bool QSqlTableModel_insertRowIntoTable(QSqlTableModel* self, QSqlRecord* values);
+bool QSqlTableModel_deleteRowFromTable(QSqlTableModel* self, int row);
+struct miqt_string QSqlTableModel_orderByClause(const QSqlTableModel* self);
+struct miqt_string QSqlTableModel_selectStatement(const QSqlTableModel* self);
+QModelIndex* QSqlTableModel_indexInQuery(const QSqlTableModel* self, QModelIndex* item);
+struct miqt_string QSqlTableModel_tr2(const char* s, const char* c);
+struct miqt_string QSqlTableModel_tr3(const char* s, const char* c, int n);
+struct miqt_string QSqlTableModel_trUtf82(const char* s, const char* c);
+struct miqt_string QSqlTableModel_trUtf83(const char* s, const char* c, int n);
+
+bool QSqlTableModel_override_virtual_setTable(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_setTable(void* self, struct miqt_string tableName);
+bool QSqlTableModel_override_virtual_flags(void* self, intptr_t slot);
+int QSqlTableModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QSqlTableModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QSqlTableModel_virtualbase_data(const void* self, QModelIndex* idx, int role);
+bool QSqlTableModel_override_virtual_setData(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role);
+bool QSqlTableModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QSqlTableModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QSqlTableModel_override_virtual_clear(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_clear(void* self);
+bool QSqlTableModel_override_virtual_setEditStrategy(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_setEditStrategy(void* self, int strategy);
+bool QSqlTableModel_override_virtual_sort(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_sort(void* self, int column, int order);
+bool QSqlTableModel_override_virtual_setSort(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_setSort(void* self, int column, int order);
+bool QSqlTableModel_override_virtual_setFilter(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_setFilter(void* self, struct miqt_string filter);
+bool QSqlTableModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QSqlTableModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_revertRow(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_revertRow(void* self, int row);
+bool QSqlTableModel_override_virtual_select(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_select(void* self);
+bool QSqlTableModel_override_virtual_selectRow(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_selectRow(void* self, int row);
+bool QSqlTableModel_override_virtual_submit(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_submit(void* self);
+bool QSqlTableModel_override_virtual_revert(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_revert(void* self);
+bool QSqlTableModel_override_virtual_updateRowInTable(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_updateRowInTable(void* self, int row, QSqlRecord* values);
+bool QSqlTableModel_override_virtual_insertRowIntoTable(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_insertRowIntoTable(void* self, QSqlRecord* values);
+bool QSqlTableModel_override_virtual_deleteRowFromTable(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_deleteRowFromTable(void* self, int row);
+bool QSqlTableModel_override_virtual_orderByClause(void* self, intptr_t slot);
+struct miqt_string QSqlTableModel_virtualbase_orderByClause(const void* self);
+bool QSqlTableModel_override_virtual_selectStatement(void* self, intptr_t slot);
+struct miqt_string QSqlTableModel_virtualbase_selectStatement(const void* self);
+bool QSqlTableModel_override_virtual_indexInQuery(void* self, intptr_t slot);
+QModelIndex* QSqlTableModel_virtualbase_indexInQuery(const void* self, QModelIndex* item);
+bool QSqlTableModel_override_virtual_columnCount(void* self, intptr_t slot);
+int QSqlTableModel_virtualbase_columnCount(const void* self, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QSqlTableModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QSqlTableModel_virtualbase_roleNames(const void* self);
+bool QSqlTableModel_override_virtual_queryChange(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_queryChange(void* self);
+bool QSqlTableModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QSqlTableModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QSqlTableModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QSqlTableModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QSqlTableModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QSqlTableModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QSqlTableModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlTableModel_virtualbase_mimeTypes(const void* self);
+bool QSqlTableModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QSqlTableModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QSqlTableModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlTableModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QSqlTableModel_virtualbase_supportedDropActions(const void* self);
+bool QSqlTableModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QSqlTableModel_virtualbase_supportedDragActions(const void* self);
+bool QSqlTableModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlTableModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlTableModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QSqlTableModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QSqlTableModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QSqlTableModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QSqlTableModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QSqlTableModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QSqlTableModel_override_virtual_event(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_event(void* self, QEvent* event);
+bool QSqlTableModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlTableModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlTableModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlTableModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlTableModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlTableModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlTableModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlTableModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QSqlTableModel_protectedbase_setPrimaryKey(bool* _dynamic_cast_ok, void* self, QSqlIndex* key);
+void QSqlTableModel_protectedbase_setQuery(bool* _dynamic_cast_ok, void* self, QSqlQuery* query);
+QSqlRecord* QSqlTableModel_protectedbase_primaryValues(bool* _dynamic_cast_ok, const void* self, int row);
+void QSqlTableModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlTableModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QSqlTableModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlTableModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+void QSqlTableModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlTableModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlTableModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlTableModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlTableModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlTableModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlTableModel_protectedbase_setLastError(bool* _dynamic_cast_ok, void* self, QSqlError* error);
+void QSqlTableModel_protectedbase_resetInternalData(bool* _dynamic_cast_ok, void* self);
+QModelIndex* QSqlTableModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+void QSqlTableModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QSqlTableModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+bool QSqlTableModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QSqlTableModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+bool QSqlTableModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QSqlTableModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlTableModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QSqlTableModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QSqlTableModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QObject* QSqlTableModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlTableModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlTableModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlTableModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlTableModel_delete(QSqlTableModel* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt/sql/gen_qtsqlglobal.cpp

@@ -0,0 +1,11 @@
+#include <qtsqlglobal.h>
+#include "gen_qtsqlglobal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+

qt/sql/gen_qtsqlglobal.go

@@ -0,0 +1,43 @@
+package sql
+
+/*
+
+#include "gen_qtsqlglobal.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+type QSql__Location int
+
+const (
+	QSql__BeforeFirstRow QSql__Location = -1
+	QSql__AfterLastRow   QSql__Location = -2
+)
+
+type QSql__ParamTypeFlag int
+
+const (
+	QSql__In     QSql__ParamTypeFlag = 1
+	QSql__Out    QSql__ParamTypeFlag = 2
+	QSql__InOut  QSql__ParamTypeFlag = 3
+	QSql__Binary QSql__ParamTypeFlag = 4
+)
+
+type QSql__TableType int
+
+const (
+	QSql__Tables       QSql__TableType = 1
+	QSql__SystemTables QSql__TableType = 2
+	QSql__Views        QSql__TableType = 4
+	QSql__AllTables    QSql__TableType = 255
+)
+
+type QSql__NumericalPrecisionPolicy int
+
+const (
+	QSql__LowPrecisionInt32  QSql__NumericalPrecisionPolicy = 1
+	QSql__LowPrecisionInt64  QSql__NumericalPrecisionPolicy = 2
+	QSql__LowPrecisionDouble QSql__NumericalPrecisionPolicy = 4
+	QSql__HighPrecision      QSql__NumericalPrecisionPolicy = 0
+)

qt/sql/gen_qtsqlglobal.h

@@ -0,0 +1,25 @@
+#pragma once
+#ifndef MIQT_QT_SQL_GEN_QTSQLGLOBAL_H
+#define MIQT_QT_SQL_GEN_QTSQLGLOBAL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#else
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/binding.go

@@ -1,3 +1 @@
 package qt6
-
-type QSysInfo__Endian int

qt6/cflags.go

@@ -4,3 +4,7 @@ package qt6
 #cgo pkg-config: Qt6Widgets
 */
 import "C"
+
+import (
+	_ "github.com/mappu/miqt/libmiqt"
+)

qt6/gen_qglobalstatic.cpp

@@ -0,0 +1,11 @@
+#include <qglobalstatic.h>
+#include "gen_qglobalstatic.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+

qt6/gen_qglobalstatic.go

@@ -0,0 +1,18 @@
+package qt6
+
+/*
+
+#include "gen_qglobalstatic.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+type QtGlobalStatic__GuardValues int
+
+const (
+	QtGlobalStatic__Destroyed     QtGlobalStatic__GuardValues = -2
+	QtGlobalStatic__Initialized   QtGlobalStatic__GuardValues = -1
+	QtGlobalStatic__Uninitialized QtGlobalStatic__GuardValues = 0
+	QtGlobalStatic__Initializing  QtGlobalStatic__GuardValues = 1
+)

qt6/gen_qglobalstatic.h

@@ -0,0 +1,25 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QGLOBALSTATIC_H
+#define MIQT_QT6_GEN_QGLOBALSTATIC_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+#else
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/gen_qsysinfo.cpp

@@ -0,0 +1,137 @@
+#include <QByteArray>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QSysInfo>
+#include <qsysinfo.h>
+#include "gen_qsysinfo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+struct miqt_string QSysInfo_buildCpuArchitecture() {
+	QString _ret = QSysInfo::buildCpuArchitecture();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_currentCpuArchitecture() {
+	QString _ret = QSysInfo::currentCpuArchitecture();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_buildAbi() {
+	QString _ret = QSysInfo::buildAbi();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_kernelType() {
+	QString _ret = QSysInfo::kernelType();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_kernelVersion() {
+	QString _ret = QSysInfo::kernelVersion();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_productType() {
+	QString _ret = QSysInfo::productType();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_productVersion() {
+	QString _ret = QSysInfo::productVersion();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_prettyProductName() {
+	QString _ret = QSysInfo::prettyProductName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_machineHostName() {
+	QString _ret = QSysInfo::machineHostName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_machineUniqueId() {
+	QByteArray _qb = QSysInfo::machineUniqueId();
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSysInfo_bootUniqueId() {
+	QByteArray _qb = QSysInfo::bootUniqueId();
+	struct miqt_string _ms;
+	_ms.len = _qb.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _qb.data(), _ms.len);
+	return _ms;
+}
+
+void QSysInfo_delete(QSysInfo* self) {
+	delete self;
+}
+

qt6/gen_qsysinfo.go

@@ -0,0 +1,151 @@
+package qt6
+
+/*
+
+#include "gen_qsysinfo.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSysInfo__Sizes int
+
+const (
+	QSysInfo__WordSize QSysInfo__Sizes = 64
+)
+
+type QSysInfo__Endian int
+
+const (
+	QSysInfo__BigEndian    QSysInfo__Endian = 0
+	QSysInfo__LittleEndian QSysInfo__Endian = 1
+	QSysInfo__ByteOrder    QSysInfo__Endian = 1
+)
+
+type QSysInfo struct {
+	h *C.QSysInfo
+}
+
+func (this *QSysInfo) cPointer() *C.QSysInfo {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSysInfo) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSysInfo constructs the type using only CGO pointers.
+func newQSysInfo(h *C.QSysInfo) *QSysInfo {
+	if h == nil {
+		return nil
+	}
+
+	return &QSysInfo{h: h}
+}
+
+// UnsafeNewQSysInfo constructs the type using only unsafe pointers.
+func UnsafeNewQSysInfo(h unsafe.Pointer) *QSysInfo {
+	return newQSysInfo((*C.QSysInfo)(h))
+}
+
+func QSysInfo_BuildCpuArchitecture() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_buildCpuArchitecture()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_CurrentCpuArchitecture() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_currentCpuArchitecture()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_BuildAbi() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_buildAbi()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_KernelType() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_kernelType()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_KernelVersion() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_kernelVersion()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_ProductType() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_productType()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_ProductVersion() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_productVersion()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_PrettyProductName() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_prettyProductName()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_MachineHostName() string {
+	var _ms C.struct_miqt_string = C.QSysInfo_machineHostName()
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSysInfo_MachineUniqueId() []byte {
+	var _bytearray C.struct_miqt_string = C.QSysInfo_machineUniqueId()
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+func QSysInfo_BootUniqueId() []byte {
+	var _bytearray C.struct_miqt_string = C.QSysInfo_bootUniqueId()
+	_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
+	C.free(unsafe.Pointer(_bytearray.data))
+	return _ret
+}
+
+// Delete this object from C++ memory.
+func (this *QSysInfo) Delete() {
+	C.QSysInfo_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSysInfo) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSysInfo) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt6/gen_qsysinfo.h

@@ -0,0 +1,41 @@
+#pragma once
+#ifndef MIQT_QT6_GEN_QSYSINFO_H
+#define MIQT_QT6_GEN_QSYSINFO_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSysInfo;
+#else
+typedef struct QSysInfo QSysInfo;
+#endif
+
+struct miqt_string QSysInfo_buildCpuArchitecture();
+struct miqt_string QSysInfo_currentCpuArchitecture();
+struct miqt_string QSysInfo_buildAbi();
+struct miqt_string QSysInfo_kernelType();
+struct miqt_string QSysInfo_kernelVersion();
+struct miqt_string QSysInfo_productType();
+struct miqt_string QSysInfo_productVersion();
+struct miqt_string QSysInfo_prettyProductName();
+struct miqt_string QSysInfo_machineHostName();
+struct miqt_string QSysInfo_machineUniqueId();
+struct miqt_string QSysInfo_bootUniqueId();
+
+void QSysInfo_delete(QSysInfo* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/qml/gen_qqmllist.cpp

@@ -18,12 +18,12 @@ QQmlListReference* QQmlListReference_new() {
 	return new (std::nothrow) QQmlListReference();
 }
 
-QQmlListReference* QQmlListReference_new2(QVariant* variant) {
-	return new (std::nothrow) QQmlListReference(*variant);
+QQmlListReference* QQmlListReference_new2(QVariant* variant, QQmlEngine* engine) {
+	return new (std::nothrow) QQmlListReference(*variant, engine);
 }
 
-QQmlListReference* QQmlListReference_new3(QObject* o, const char* property) {
-	return new (std::nothrow) QQmlListReference(o, property);
+QQmlListReference* QQmlListReference_new3(QObject* o, const char* property, QQmlEngine* engine) {
+	return new (std::nothrow) QQmlListReference(o, property, engine);
 }
 
 QQmlListReference* QQmlListReference_new4(QVariant* variant) {
@@ -38,14 +38,6 @@ QQmlListReference* QQmlListReference_new6(QQmlListReference* param1) {
 	return new (std::nothrow) QQmlListReference(*param1);
 }
 
-QQmlListReference* QQmlListReference_new7(QVariant* variant, QQmlEngine* engine) {
-	return new (std::nothrow) QQmlListReference(*variant, engine);
-}
-
-QQmlListReference* QQmlListReference_new8(QObject* o, const char* property, QQmlEngine* engine) {
-	return new (std::nothrow) QQmlListReference(o, property, engine);
-}
-
 void QQmlListReference_operatorAssign(QQmlListReference* self, QQmlListReference* param1) {
 	self->operator=(*param1);
 }

qt6/qml/gen_qqmllist.go

@@ -53,17 +53,17 @@ func NewQQmlListReference() *QQmlListReference {
 }
 
 // NewQQmlListReference2 constructs a new QQmlListReference object.
-func NewQQmlListReference2(variant *qt6.QVariant) *QQmlListReference {
+func NewQQmlListReference2(variant *qt6.QVariant, engine *QQmlEngine) *QQmlListReference {
 
-	return newQQmlListReference(C.QQmlListReference_new2((*C.QVariant)(variant.UnsafePointer())))
+	return newQQmlListReference(C.QQmlListReference_new2((*C.QVariant)(variant.UnsafePointer()), engine.cPointer()))
 }
 
 // NewQQmlListReference3 constructs a new QQmlListReference object.
-func NewQQmlListReference3(o *qt6.QObject, property string) *QQmlListReference {
+func NewQQmlListReference3(o *qt6.QObject, property string, engine *QQmlEngine) *QQmlListReference {
 	property_Cstring := C.CString(property)
 	defer C.free(unsafe.Pointer(property_Cstring))
 
-	return newQQmlListReference(C.QQmlListReference_new3((*C.QObject)(o.UnsafePointer()), property_Cstring))
+	return newQQmlListReference(C.QQmlListReference_new3((*C.QObject)(o.UnsafePointer()), property_Cstring, engine.cPointer()))
 }
 
 // NewQQmlListReference4 constructs a new QQmlListReference object.
@@ -86,20 +86,6 @@ func NewQQmlListReference6(param1 *QQmlListReference) *QQmlListReference {
 	return newQQmlListReference(C.QQmlListReference_new6(param1.cPointer()))
 }
 
-// NewQQmlListReference7 constructs a new QQmlListReference object.
-func NewQQmlListReference7(variant *qt6.QVariant, engine *QQmlEngine) *QQmlListReference {
-
-	return newQQmlListReference(C.QQmlListReference_new7((*C.QVariant)(variant.UnsafePointer()), engine.cPointer()))
-}
-
-// NewQQmlListReference8 constructs a new QQmlListReference object.
-func NewQQmlListReference8(o *qt6.QObject, property string, engine *QQmlEngine) *QQmlListReference {
-	property_Cstring := C.CString(property)
-	defer C.free(unsafe.Pointer(property_Cstring))
-
-	return newQQmlListReference(C.QQmlListReference_new8((*C.QObject)(o.UnsafePointer()), property_Cstring, engine.cPointer()))
-}
-
 func (this *QQmlListReference) OperatorAssign(param1 *QQmlListReference) {
 	C.QQmlListReference_operatorAssign(this.h, param1.cPointer())
 }

qt6/qml/gen_qqmllist.h

@@ -29,13 +29,11 @@ typedef struct QVariant QVariant;
 #endif
 
 QQmlListReference* QQmlListReference_new();
-QQmlListReference* QQmlListReference_new2(QVariant* variant);
-QQmlListReference* QQmlListReference_new3(QObject* o, const char* property);
+QQmlListReference* QQmlListReference_new2(QVariant* variant, QQmlEngine* engine);
+QQmlListReference* QQmlListReference_new3(QObject* o, const char* property, QQmlEngine* engine);
 QQmlListReference* QQmlListReference_new4(QVariant* variant);
 QQmlListReference* QQmlListReference_new5(QObject* o, const char* property);
 QQmlListReference* QQmlListReference_new6(QQmlListReference* param1);
-QQmlListReference* QQmlListReference_new7(QVariant* variant, QQmlEngine* engine);
-QQmlListReference* QQmlListReference_new8(QObject* o, const char* property, QQmlEngine* engine);
 void QQmlListReference_operatorAssign(QQmlListReference* self, QQmlListReference* param1);
 bool QQmlListReference_isValid(const QQmlListReference* self);
 QObject* QQmlListReference_object(const QQmlListReference* self);

qt6/sql/cflags.go

@@ -0,0 +1,6 @@
+package sql
+
+/*
+#cgo pkg-config: Qt6Sql
+*/
+import "C"

qt6/sql/gen_qsqldatabase.cpp

@@ -0,0 +1,387 @@
+#include <QList>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QSqlDriverCreatorBase>
+#include <QSqlError>
+#include <QSqlIndex>
+#include <QSqlQuery>
+#include <QSqlRecord>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qsqldatabase.h>
+#include "gen_qsqldatabase.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlDriver* QSqlDriverCreatorBase_createObject(const QSqlDriverCreatorBase* self) {
+	return self->createObject();
+}
+
+void QSqlDriverCreatorBase_operatorAssign(QSqlDriverCreatorBase* self, QSqlDriverCreatorBase* param1) {
+	self->operator=(*param1);
+}
+
+void QSqlDriverCreatorBase_delete(QSqlDriverCreatorBase* self) {
+	delete self;
+}
+
+QSqlDatabase* QSqlDatabase_new() {
+	return new (std::nothrow) QSqlDatabase();
+}
+
+QSqlDatabase* QSqlDatabase_new2(QSqlDatabase* other) {
+	return new (std::nothrow) QSqlDatabase(*other);
+}
+
+void QSqlDatabase_operatorAssign(QSqlDatabase* self, QSqlDatabase* other) {
+	self->operator=(*other);
+}
+
+bool QSqlDatabase_open(QSqlDatabase* self) {
+	return self->open();
+}
+
+bool QSqlDatabase_open2(QSqlDatabase* self, struct miqt_string user, struct miqt_string password) {
+	QString user_QString = QString::fromUtf8(user.data, user.len);
+	QString password_QString = QString::fromUtf8(password.data, password.len);
+	return self->open(user_QString, password_QString);
+}
+
+void QSqlDatabase_close(QSqlDatabase* self) {
+	self->close();
+}
+
+bool QSqlDatabase_isOpen(const QSqlDatabase* self) {
+	return self->isOpen();
+}
+
+bool QSqlDatabase_isOpenError(const QSqlDatabase* self) {
+	return self->isOpenError();
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tables(const QSqlDatabase* self) {
+	QStringList _ret = self->tables();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+QSqlIndex* QSqlDatabase_primaryIndex(const QSqlDatabase* self, struct miqt_string tablename) {
+	QString tablename_QString = QString::fromUtf8(tablename.data, tablename.len);
+	return new QSqlIndex(self->primaryIndex(tablename_QString));
+}
+
+QSqlRecord* QSqlDatabase_record(const QSqlDatabase* self, struct miqt_string tablename) {
+	QString tablename_QString = QString::fromUtf8(tablename.data, tablename.len);
+	return new QSqlRecord(self->record(tablename_QString));
+}
+
+QSqlQuery* QSqlDatabase_exec(const QSqlDatabase* self) {
+	return new QSqlQuery(self->exec());
+}
+
+QSqlError* QSqlDatabase_lastError(const QSqlDatabase* self) {
+	return new QSqlError(self->lastError());
+}
+
+bool QSqlDatabase_isValid(const QSqlDatabase* self) {
+	return self->isValid();
+}
+
+bool QSqlDatabase_transaction(QSqlDatabase* self) {
+	return self->transaction();
+}
+
+bool QSqlDatabase_commit(QSqlDatabase* self) {
+	return self->commit();
+}
+
+bool QSqlDatabase_rollback(QSqlDatabase* self) {
+	return self->rollback();
+}
+
+void QSqlDatabase_setDatabaseName(QSqlDatabase* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setDatabaseName(name_QString);
+}
+
+void QSqlDatabase_setUserName(QSqlDatabase* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setUserName(name_QString);
+}
+
+void QSqlDatabase_setPassword(QSqlDatabase* self, struct miqt_string password) {
+	QString password_QString = QString::fromUtf8(password.data, password.len);
+	self->setPassword(password_QString);
+}
+
+void QSqlDatabase_setHostName(QSqlDatabase* self, struct miqt_string host) {
+	QString host_QString = QString::fromUtf8(host.data, host.len);
+	self->setHostName(host_QString);
+}
+
+void QSqlDatabase_setPort(QSqlDatabase* self, int p) {
+	self->setPort(static_cast<int>(p));
+}
+
+void QSqlDatabase_setConnectOptions(QSqlDatabase* self) {
+	self->setConnectOptions();
+}
+
+struct miqt_string QSqlDatabase_databaseName(const QSqlDatabase* self) {
+	QString _ret = self->databaseName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_userName(const QSqlDatabase* self) {
+	QString _ret = self->userName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_password(const QSqlDatabase* self) {
+	QString _ret = self->password();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_hostName(const QSqlDatabase* self) {
+	QString _ret = self->hostName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_driverName(const QSqlDatabase* self) {
+	QString _ret = self->driverName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QSqlDatabase_port(const QSqlDatabase* self) {
+	return self->port();
+}
+
+struct miqt_string QSqlDatabase_connectOptions(const QSqlDatabase* self) {
+	QString _ret = self->connectOptions();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDatabase_connectionName(const QSqlDatabase* self) {
+	QString _ret = self->connectionName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlDatabase_setNumericalPrecisionPolicy(QSqlDatabase* self, int precisionPolicy) {
+	self->setNumericalPrecisionPolicy(static_cast<QSql::NumericalPrecisionPolicy>(precisionPolicy));
+}
+
+int QSqlDatabase_numericalPrecisionPolicy(const QSqlDatabase* self) {
+	QSql::NumericalPrecisionPolicy _ret = self->numericalPrecisionPolicy();
+	return static_cast<int>(_ret);
+}
+
+QSqlDriver* QSqlDatabase_driver(const QSqlDatabase* self) {
+	return self->driver();
+}
+
+QSqlDatabase* QSqlDatabase_addDatabase(struct miqt_string type) {
+	QString type_QString = QString::fromUtf8(type.data, type.len);
+	return new QSqlDatabase(QSqlDatabase::addDatabase(type_QString));
+}
+
+QSqlDatabase* QSqlDatabase_addDatabaseWithDriver(QSqlDriver* driver) {
+	return new QSqlDatabase(QSqlDatabase::addDatabase(driver));
+}
+
+QSqlDatabase* QSqlDatabase_cloneDatabase(QSqlDatabase* other, struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::cloneDatabase(*other, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_cloneDatabase2(struct miqt_string other, struct miqt_string connectionName) {
+	QString other_QString = QString::fromUtf8(other.data, other.len);
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::cloneDatabase(other_QString, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_database() {
+	return new QSqlDatabase(QSqlDatabase::database());
+}
+
+void QSqlDatabase_removeDatabase(struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	QSqlDatabase::removeDatabase(connectionName_QString);
+}
+
+bool QSqlDatabase_contains() {
+	return QSqlDatabase::contains();
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_drivers() {
+	QStringList _ret = QSqlDatabase::drivers();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_connectionNames() {
+	QStringList _ret = QSqlDatabase::connectionNames();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+void QSqlDatabase_registerSqlDriver(struct miqt_string name, QSqlDriverCreatorBase* creator) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	QSqlDatabase::registerSqlDriver(name_QString, creator);
+}
+
+bool QSqlDatabase_isDriverAvailable(struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return QSqlDatabase::isDriverAvailable(name_QString);
+}
+
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tablesWithType(const QSqlDatabase* self, int type) {
+	QStringList _ret = self->tables(static_cast<QSql::TableType>(type));
+	// Convert QList<> from C++ memory to manually-managed C memory
+	struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		QString _lv_ret = _ret[i];
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray _lv_b = _lv_ret.toUtf8();
+		struct miqt_string _lv_ms;
+		_lv_ms.len = _lv_b.length();
+		_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
+		memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
+		_arr[i] = _lv_ms;
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+QSqlQuery* QSqlDatabase_execWithQuery(const QSqlDatabase* self, struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return new QSqlQuery(self->exec(query_QString));
+}
+
+void QSqlDatabase_setConnectOptionsWithOptions(QSqlDatabase* self, struct miqt_string options) {
+	QString options_QString = QString::fromUtf8(options.data, options.len);
+	self->setConnectOptions(options_QString);
+}
+
+QSqlDatabase* QSqlDatabase_addDatabase2(struct miqt_string type, struct miqt_string connectionName) {
+	QString type_QString = QString::fromUtf8(type.data, type.len);
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::addDatabase(type_QString, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_addDatabase3(QSqlDriver* driver, struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::addDatabase(driver, connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_databaseWithConnectionName(struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::database(connectionName_QString));
+}
+
+QSqlDatabase* QSqlDatabase_database2(struct miqt_string connectionName, bool open) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return new QSqlDatabase(QSqlDatabase::database(connectionName_QString, open));
+}
+
+bool QSqlDatabase_containsWithConnectionName(struct miqt_string connectionName) {
+	QString connectionName_QString = QString::fromUtf8(connectionName.data, connectionName.len);
+	return QSqlDatabase::contains(connectionName_QString);
+}
+
+void QSqlDatabase_delete(QSqlDatabase* self) {
+	delete self;
+}
+

qt6/sql/gen_qsqldatabase.go

@@ -0,0 +1,507 @@
+package sql
+
+/*
+
+#include "gen_qsqldatabase.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSqlDriverCreatorBase struct {
+	h *C.QSqlDriverCreatorBase
+}
+
+func (this *QSqlDriverCreatorBase) cPointer() *C.QSqlDriverCreatorBase {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlDriverCreatorBase) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlDriverCreatorBase constructs the type using only CGO pointers.
+func newQSqlDriverCreatorBase(h *C.QSqlDriverCreatorBase) *QSqlDriverCreatorBase {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlDriverCreatorBase{h: h}
+}
+
+// UnsafeNewQSqlDriverCreatorBase constructs the type using only unsafe pointers.
+func UnsafeNewQSqlDriverCreatorBase(h unsafe.Pointer) *QSqlDriverCreatorBase {
+	return newQSqlDriverCreatorBase((*C.QSqlDriverCreatorBase)(h))
+}
+
+func (this *QSqlDriverCreatorBase) CreateObject() *QSqlDriver {
+	return newQSqlDriver(C.QSqlDriverCreatorBase_createObject(this.h))
+}
+
+func (this *QSqlDriverCreatorBase) OperatorAssign(param1 *QSqlDriverCreatorBase) {
+	C.QSqlDriverCreatorBase_operatorAssign(this.h, param1.cPointer())
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlDriverCreatorBase) Delete() {
+	C.QSqlDriverCreatorBase_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlDriverCreatorBase) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlDriverCreatorBase) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}
+
+type QSqlDatabase struct {
+	h *C.QSqlDatabase
+}
+
+func (this *QSqlDatabase) cPointer() *C.QSqlDatabase {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlDatabase) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlDatabase constructs the type using only CGO pointers.
+func newQSqlDatabase(h *C.QSqlDatabase) *QSqlDatabase {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlDatabase{h: h}
+}
+
+// UnsafeNewQSqlDatabase constructs the type using only unsafe pointers.
+func UnsafeNewQSqlDatabase(h unsafe.Pointer) *QSqlDatabase {
+	return newQSqlDatabase((*C.QSqlDatabase)(h))
+}
+
+// NewQSqlDatabase constructs a new QSqlDatabase object.
+func NewQSqlDatabase() *QSqlDatabase {
+
+	return newQSqlDatabase(C.QSqlDatabase_new())
+}
+
+// NewQSqlDatabase2 constructs a new QSqlDatabase object.
+func NewQSqlDatabase2(other *QSqlDatabase) *QSqlDatabase {
+
+	return newQSqlDatabase(C.QSqlDatabase_new2(other.cPointer()))
+}
+
+func (this *QSqlDatabase) OperatorAssign(other *QSqlDatabase) {
+	C.QSqlDatabase_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlDatabase) Open() bool {
+	return (bool)(C.QSqlDatabase_open(this.h))
+}
+
+func (this *QSqlDatabase) Open2(user string, password string) bool {
+	user_ms := C.struct_miqt_string{}
+	user_ms.data = C.CString(user)
+	user_ms.len = C.size_t(len(user))
+	defer C.free(unsafe.Pointer(user_ms.data))
+	password_ms := C.struct_miqt_string{}
+	password_ms.data = C.CString(password)
+	password_ms.len = C.size_t(len(password))
+	defer C.free(unsafe.Pointer(password_ms.data))
+	return (bool)(C.QSqlDatabase_open2(this.h, user_ms, password_ms))
+}
+
+func (this *QSqlDatabase) Close() {
+	C.QSqlDatabase_close(this.h)
+}
+
+func (this *QSqlDatabase) IsOpen() bool {
+	return (bool)(C.QSqlDatabase_isOpen(this.h))
+}
+
+func (this *QSqlDatabase) IsOpenError() bool {
+	return (bool)(C.QSqlDatabase_isOpenError(this.h))
+}
+
+func (this *QSqlDatabase) Tables() []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_tables(this.h)
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func (this *QSqlDatabase) PrimaryIndex(tablename string) *QSqlIndex {
+	tablename_ms := C.struct_miqt_string{}
+	tablename_ms.data = C.CString(tablename)
+	tablename_ms.len = C.size_t(len(tablename))
+	defer C.free(unsafe.Pointer(tablename_ms.data))
+	_goptr := newQSqlIndex(C.QSqlDatabase_primaryIndex(this.h, tablename_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) Record(tablename string) *QSqlRecord {
+	tablename_ms := C.struct_miqt_string{}
+	tablename_ms.data = C.CString(tablename)
+	tablename_ms.len = C.size_t(len(tablename))
+	defer C.free(unsafe.Pointer(tablename_ms.data))
+	_goptr := newQSqlRecord(C.QSqlDatabase_record(this.h, tablename_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) Exec() *QSqlQuery {
+	_goptr := newQSqlQuery(C.QSqlDatabase_exec(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) LastError() *QSqlError {
+	_goptr := newQSqlError(C.QSqlDatabase_lastError(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) IsValid() bool {
+	return (bool)(C.QSqlDatabase_isValid(this.h))
+}
+
+func (this *QSqlDatabase) Transaction() bool {
+	return (bool)(C.QSqlDatabase_transaction(this.h))
+}
+
+func (this *QSqlDatabase) Commit() bool {
+	return (bool)(C.QSqlDatabase_commit(this.h))
+}
+
+func (this *QSqlDatabase) Rollback() bool {
+	return (bool)(C.QSqlDatabase_rollback(this.h))
+}
+
+func (this *QSqlDatabase) SetDatabaseName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlDatabase_setDatabaseName(this.h, name_ms)
+}
+
+func (this *QSqlDatabase) SetUserName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlDatabase_setUserName(this.h, name_ms)
+}
+
+func (this *QSqlDatabase) SetPassword(password string) {
+	password_ms := C.struct_miqt_string{}
+	password_ms.data = C.CString(password)
+	password_ms.len = C.size_t(len(password))
+	defer C.free(unsafe.Pointer(password_ms.data))
+	C.QSqlDatabase_setPassword(this.h, password_ms)
+}
+
+func (this *QSqlDatabase) SetHostName(host string) {
+	host_ms := C.struct_miqt_string{}
+	host_ms.data = C.CString(host)
+	host_ms.len = C.size_t(len(host))
+	defer C.free(unsafe.Pointer(host_ms.data))
+	C.QSqlDatabase_setHostName(this.h, host_ms)
+}
+
+func (this *QSqlDatabase) SetPort(p int) {
+	C.QSqlDatabase_setPort(this.h, (C.int)(p))
+}
+
+func (this *QSqlDatabase) SetConnectOptions() {
+	C.QSqlDatabase_setConnectOptions(this.h)
+}
+
+func (this *QSqlDatabase) DatabaseName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_databaseName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) UserName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_userName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) Password() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_password(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) HostName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_hostName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) DriverName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_driverName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) Port() int {
+	return (int)(C.QSqlDatabase_port(this.h))
+}
+
+func (this *QSqlDatabase) ConnectOptions() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_connectOptions(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) ConnectionName() string {
+	var _ms C.struct_miqt_string = C.QSqlDatabase_connectionName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDatabase) SetNumericalPrecisionPolicy(precisionPolicy QSql__NumericalPrecisionPolicy) {
+	C.QSqlDatabase_setNumericalPrecisionPolicy(this.h, (C.int)(precisionPolicy))
+}
+
+func (this *QSqlDatabase) NumericalPrecisionPolicy() QSql__NumericalPrecisionPolicy {
+	return (QSql__NumericalPrecisionPolicy)(C.QSqlDatabase_numericalPrecisionPolicy(this.h))
+}
+
+func (this *QSqlDatabase) Driver() *QSqlDriver {
+	return newQSqlDriver(C.QSqlDatabase_driver(this.h))
+}
+
+func QSqlDatabase_AddDatabase(typeVal string) *QSqlDatabase {
+	typeVal_ms := C.struct_miqt_string{}
+	typeVal_ms.data = C.CString(typeVal)
+	typeVal_ms.len = C.size_t(len(typeVal))
+	defer C.free(unsafe.Pointer(typeVal_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabase(typeVal_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_AddDatabaseWithDriver(driver *QSqlDriver) *QSqlDatabase {
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabaseWithDriver(driver.cPointer()))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_CloneDatabase(other *QSqlDatabase, connectionName string) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_cloneDatabase(other.cPointer(), connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_CloneDatabase2(other string, connectionName string) *QSqlDatabase {
+	other_ms := C.struct_miqt_string{}
+	other_ms.data = C.CString(other)
+	other_ms.len = C.size_t(len(other))
+	defer C.free(unsafe.Pointer(other_ms.data))
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_cloneDatabase2(other_ms, connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_Database() *QSqlDatabase {
+	_goptr := newQSqlDatabase(C.QSqlDatabase_database())
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_RemoveDatabase(connectionName string) {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	C.QSqlDatabase_removeDatabase(connectionName_ms)
+}
+
+func QSqlDatabase_Contains() bool {
+	return (bool)(C.QSqlDatabase_contains())
+}
+
+func QSqlDatabase_Drivers() []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_drivers()
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func QSqlDatabase_ConnectionNames() []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_connectionNames()
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func QSqlDatabase_RegisterSqlDriver(name string, creator *QSqlDriverCreatorBase) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlDatabase_registerSqlDriver(name_ms, creator.cPointer())
+}
+
+func QSqlDatabase_IsDriverAvailable(name string) bool {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (bool)(C.QSqlDatabase_isDriverAvailable(name_ms))
+}
+
+func (this *QSqlDatabase) TablesWithType(typeVal QSql__TableType) []string {
+	var _ma C.struct_miqt_array = C.QSqlDatabase_tablesWithType(this.h, (C.int)(typeVal))
+	_ret := make([]string, int(_ma.len))
+	_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		var _lv_ms C.struct_miqt_string = _outCast[i]
+		_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
+		C.free(unsafe.Pointer(_lv_ms.data))
+		_ret[i] = _lv_ret
+	}
+	return _ret
+}
+
+func (this *QSqlDatabase) ExecWithQuery(query string) *QSqlQuery {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+	_goptr := newQSqlQuery(C.QSqlDatabase_execWithQuery(this.h, query_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlDatabase) SetConnectOptionsWithOptions(options string) {
+	options_ms := C.struct_miqt_string{}
+	options_ms.data = C.CString(options)
+	options_ms.len = C.size_t(len(options))
+	defer C.free(unsafe.Pointer(options_ms.data))
+	C.QSqlDatabase_setConnectOptionsWithOptions(this.h, options_ms)
+}
+
+func QSqlDatabase_AddDatabase2(typeVal string, connectionName string) *QSqlDatabase {
+	typeVal_ms := C.struct_miqt_string{}
+	typeVal_ms.data = C.CString(typeVal)
+	typeVal_ms.len = C.size_t(len(typeVal))
+	defer C.free(unsafe.Pointer(typeVal_ms.data))
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabase2(typeVal_ms, connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_AddDatabase3(driver *QSqlDriver, connectionName string) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_addDatabase3(driver.cPointer(), connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_DatabaseWithConnectionName(connectionName string) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_databaseWithConnectionName(connectionName_ms))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_Database2(connectionName string, open bool) *QSqlDatabase {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	_goptr := newQSqlDatabase(C.QSqlDatabase_database2(connectionName_ms, (C.bool)(open)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func QSqlDatabase_ContainsWithConnectionName(connectionName string) bool {
+	connectionName_ms := C.struct_miqt_string{}
+	connectionName_ms.data = C.CString(connectionName)
+	connectionName_ms.len = C.size_t(len(connectionName))
+	defer C.free(unsafe.Pointer(connectionName_ms.data))
+	return (bool)(C.QSqlDatabase_containsWithConnectionName(connectionName_ms))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlDatabase) Delete() {
+	C.QSqlDatabase_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlDatabase) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlDatabase) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt6/sql/gen_qsqldatabase.h

@@ -0,0 +1,100 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLDATABASE_H
+#define MIQT_QT6_SQL_GEN_QSQLDATABASE_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlDatabase;
+class QSqlDriver;
+class QSqlDriverCreatorBase;
+class QSqlError;
+class QSqlIndex;
+class QSqlQuery;
+class QSqlRecord;
+#else
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlDriverCreatorBase QSqlDriverCreatorBase;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlRecord QSqlRecord;
+#endif
+
+QSqlDriver* QSqlDriverCreatorBase_createObject(const QSqlDriverCreatorBase* self);
+void QSqlDriverCreatorBase_operatorAssign(QSqlDriverCreatorBase* self, QSqlDriverCreatorBase* param1);
+
+void QSqlDriverCreatorBase_delete(QSqlDriverCreatorBase* self);
+
+QSqlDatabase* QSqlDatabase_new();
+QSqlDatabase* QSqlDatabase_new2(QSqlDatabase* other);
+void QSqlDatabase_operatorAssign(QSqlDatabase* self, QSqlDatabase* other);
+bool QSqlDatabase_open(QSqlDatabase* self);
+bool QSqlDatabase_open2(QSqlDatabase* self, struct miqt_string user, struct miqt_string password);
+void QSqlDatabase_close(QSqlDatabase* self);
+bool QSqlDatabase_isOpen(const QSqlDatabase* self);
+bool QSqlDatabase_isOpenError(const QSqlDatabase* self);
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tables(const QSqlDatabase* self);
+QSqlIndex* QSqlDatabase_primaryIndex(const QSqlDatabase* self, struct miqt_string tablename);
+QSqlRecord* QSqlDatabase_record(const QSqlDatabase* self, struct miqt_string tablename);
+QSqlQuery* QSqlDatabase_exec(const QSqlDatabase* self);
+QSqlError* QSqlDatabase_lastError(const QSqlDatabase* self);
+bool QSqlDatabase_isValid(const QSqlDatabase* self);
+bool QSqlDatabase_transaction(QSqlDatabase* self);
+bool QSqlDatabase_commit(QSqlDatabase* self);
+bool QSqlDatabase_rollback(QSqlDatabase* self);
+void QSqlDatabase_setDatabaseName(QSqlDatabase* self, struct miqt_string name);
+void QSqlDatabase_setUserName(QSqlDatabase* self, struct miqt_string name);
+void QSqlDatabase_setPassword(QSqlDatabase* self, struct miqt_string password);
+void QSqlDatabase_setHostName(QSqlDatabase* self, struct miqt_string host);
+void QSqlDatabase_setPort(QSqlDatabase* self, int p);
+void QSqlDatabase_setConnectOptions(QSqlDatabase* self);
+struct miqt_string QSqlDatabase_databaseName(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_userName(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_password(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_hostName(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_driverName(const QSqlDatabase* self);
+int QSqlDatabase_port(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_connectOptions(const QSqlDatabase* self);
+struct miqt_string QSqlDatabase_connectionName(const QSqlDatabase* self);
+void QSqlDatabase_setNumericalPrecisionPolicy(QSqlDatabase* self, int precisionPolicy);
+int QSqlDatabase_numericalPrecisionPolicy(const QSqlDatabase* self);
+QSqlDriver* QSqlDatabase_driver(const QSqlDatabase* self);
+QSqlDatabase* QSqlDatabase_addDatabase(struct miqt_string type);
+QSqlDatabase* QSqlDatabase_addDatabaseWithDriver(QSqlDriver* driver);
+QSqlDatabase* QSqlDatabase_cloneDatabase(QSqlDatabase* other, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_cloneDatabase2(struct miqt_string other, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_database();
+void QSqlDatabase_removeDatabase(struct miqt_string connectionName);
+bool QSqlDatabase_contains();
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_drivers();
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_connectionNames();
+void QSqlDatabase_registerSqlDriver(struct miqt_string name, QSqlDriverCreatorBase* creator);
+bool QSqlDatabase_isDriverAvailable(struct miqt_string name);
+struct miqt_array /* of struct miqt_string */  QSqlDatabase_tablesWithType(const QSqlDatabase* self, int type);
+QSqlQuery* QSqlDatabase_execWithQuery(const QSqlDatabase* self, struct miqt_string query);
+void QSqlDatabase_setConnectOptionsWithOptions(QSqlDatabase* self, struct miqt_string options);
+QSqlDatabase* QSqlDatabase_addDatabase2(struct miqt_string type, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_addDatabase3(QSqlDriver* driver, struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_databaseWithConnectionName(struct miqt_string connectionName);
+QSqlDatabase* QSqlDatabase_database2(struct miqt_string connectionName, bool open);
+bool QSqlDatabase_containsWithConnectionName(struct miqt_string connectionName);
+
+void QSqlDatabase_delete(QSqlDatabase* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqldriver.h

@@ -0,0 +1,164 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLDRIVER_H
+#define MIQT_QT6_SQL_GEN_QSQLDRIVER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QSqlDriver;
+class QSqlError;
+class QSqlField;
+class QSqlIndex;
+class QSqlRecord;
+class QSqlResult;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlField QSqlField;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QSqlResult QSqlResult;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlDriver* QSqlDriver_new();
+QSqlDriver* QSqlDriver_new2(QObject* parent);
+void QSqlDriver_virtbase(QSqlDriver* src, QObject** outptr_QObject);
+QMetaObject* QSqlDriver_metaObject(const QSqlDriver* self);
+void* QSqlDriver_metacast(QSqlDriver* self, const char* param1);
+struct miqt_string QSqlDriver_tr(const char* s);
+bool QSqlDriver_isOpen(const QSqlDriver* self);
+bool QSqlDriver_isOpenError(const QSqlDriver* self);
+bool QSqlDriver_beginTransaction(QSqlDriver* self);
+bool QSqlDriver_commitTransaction(QSqlDriver* self);
+bool QSqlDriver_rollbackTransaction(QSqlDriver* self);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_tables(const QSqlDriver* self, int tableType);
+QSqlIndex* QSqlDriver_primaryIndex(const QSqlDriver* self, struct miqt_string tableName);
+QSqlRecord* QSqlDriver_record(const QSqlDriver* self, struct miqt_string tableName);
+struct miqt_string QSqlDriver_formatValue(const QSqlDriver* self, QSqlField* field, bool trimStrings);
+struct miqt_string QSqlDriver_escapeIdentifier(const QSqlDriver* self, struct miqt_string identifier, int type);
+struct miqt_string QSqlDriver_sqlStatement(const QSqlDriver* self, int type, struct miqt_string tableName, QSqlRecord* rec, bool preparedStatement);
+QSqlError* QSqlDriver_lastError(const QSqlDriver* self);
+QVariant* QSqlDriver_handle(const QSqlDriver* self);
+bool QSqlDriver_hasFeature(const QSqlDriver* self, int f);
+void QSqlDriver_close(QSqlDriver* self);
+QSqlResult* QSqlDriver_createResult(const QSqlDriver* self);
+bool QSqlDriver_open(QSqlDriver* self, struct miqt_string db, struct miqt_string user, struct miqt_string password, struct miqt_string host, int port, struct miqt_string connOpts);
+bool QSqlDriver_subscribeToNotification(QSqlDriver* self, struct miqt_string name);
+bool QSqlDriver_unsubscribeFromNotification(QSqlDriver* self, struct miqt_string name);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_subscribedToNotifications(const QSqlDriver* self);
+bool QSqlDriver_isIdentifierEscaped(const QSqlDriver* self, struct miqt_string identifier, int type);
+struct miqt_string QSqlDriver_stripDelimiters(const QSqlDriver* self, struct miqt_string identifier, int type);
+void QSqlDriver_setNumericalPrecisionPolicy(QSqlDriver* self, int precisionPolicy);
+int QSqlDriver_numericalPrecisionPolicy(const QSqlDriver* self);
+int QSqlDriver_dbmsType(const QSqlDriver* self);
+int QSqlDriver_maximumIdentifierLength(const QSqlDriver* self, int type);
+bool QSqlDriver_cancelQuery(QSqlDriver* self);
+void QSqlDriver_notification(QSqlDriver* self, struct miqt_string name, int source, QVariant* payload);
+void QSqlDriver_connect_notification(QSqlDriver* self, intptr_t slot);
+void QSqlDriver_setOpen(QSqlDriver* self, bool o);
+void QSqlDriver_setOpenError(QSqlDriver* self, bool e);
+void QSqlDriver_setLastError(QSqlDriver* self, QSqlError* e);
+struct miqt_string QSqlDriver_tr2(const char* s, const char* c);
+struct miqt_string QSqlDriver_tr3(const char* s, const char* c, int n);
+
+bool QSqlDriver_override_virtual_isOpen(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_isOpen(const void* self);
+bool QSqlDriver_override_virtual_beginTransaction(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_beginTransaction(void* self);
+bool QSqlDriver_override_virtual_commitTransaction(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_commitTransaction(void* self);
+bool QSqlDriver_override_virtual_rollbackTransaction(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_rollbackTransaction(void* self);
+bool QSqlDriver_override_virtual_tables(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_virtualbase_tables(const void* self, int tableType);
+bool QSqlDriver_override_virtual_primaryIndex(void* self, intptr_t slot);
+QSqlIndex* QSqlDriver_virtualbase_primaryIndex(const void* self, struct miqt_string tableName);
+bool QSqlDriver_override_virtual_record(void* self, intptr_t slot);
+QSqlRecord* QSqlDriver_virtualbase_record(const void* self, struct miqt_string tableName);
+bool QSqlDriver_override_virtual_formatValue(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_formatValue(const void* self, QSqlField* field, bool trimStrings);
+bool QSqlDriver_override_virtual_escapeIdentifier(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_escapeIdentifier(const void* self, struct miqt_string identifier, int type);
+bool QSqlDriver_override_virtual_sqlStatement(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_sqlStatement(const void* self, int type, struct miqt_string tableName, QSqlRecord* rec, bool preparedStatement);
+bool QSqlDriver_override_virtual_handle(void* self, intptr_t slot);
+QVariant* QSqlDriver_virtualbase_handle(const void* self);
+bool QSqlDriver_override_virtual_hasFeature(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_hasFeature(const void* self, int f);
+bool QSqlDriver_override_virtual_close(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_close(void* self);
+bool QSqlDriver_override_virtual_createResult(void* self, intptr_t slot);
+QSqlResult* QSqlDriver_virtualbase_createResult(const void* self);
+bool QSqlDriver_override_virtual_open(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_open(void* self, struct miqt_string db, struct miqt_string user, struct miqt_string password, struct miqt_string host, int port, struct miqt_string connOpts);
+bool QSqlDriver_override_virtual_subscribeToNotification(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_subscribeToNotification(void* self, struct miqt_string name);
+bool QSqlDriver_override_virtual_unsubscribeFromNotification(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_unsubscribeFromNotification(void* self, struct miqt_string name);
+bool QSqlDriver_override_virtual_subscribedToNotifications(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlDriver_virtualbase_subscribedToNotifications(const void* self);
+bool QSqlDriver_override_virtual_isIdentifierEscaped(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_isIdentifierEscaped(const void* self, struct miqt_string identifier, int type);
+bool QSqlDriver_override_virtual_stripDelimiters(void* self, intptr_t slot);
+struct miqt_string QSqlDriver_virtualbase_stripDelimiters(const void* self, struct miqt_string identifier, int type);
+bool QSqlDriver_override_virtual_maximumIdentifierLength(void* self, intptr_t slot);
+int QSqlDriver_virtualbase_maximumIdentifierLength(const void* self, int type);
+bool QSqlDriver_override_virtual_cancelQuery(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_cancelQuery(void* self);
+bool QSqlDriver_override_virtual_setOpen(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_setOpen(void* self, bool o);
+bool QSqlDriver_override_virtual_setOpenError(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_setOpenError(void* self, bool e);
+bool QSqlDriver_override_virtual_setLastError(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_setLastError(void* self, QSqlError* e);
+bool QSqlDriver_override_virtual_event(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_event(void* self, QEvent* event);
+bool QSqlDriver_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlDriver_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlDriver_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlDriver_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlDriver_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlDriver_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlDriver_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlDriver_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QSqlDriver_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriver_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriver_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlDriver_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlDriver_delete(QSqlDriver* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqldriverplugin.cpp

@@ -0,0 +1,402 @@
+#include <QChildEvent>
+#include <QEvent>
+#include <QMetaMethod>
+#include <QMetaObject>
+#include <QObject>
+#include <QSqlDriver>
+#include <QSqlDriverPlugin>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QTimerEvent>
+#include <qsqldriverplugin.h>
+#include "gen_qsqldriverplugin.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+QSqlDriver* miqt_exec_callback_QSqlDriverPlugin_create(QSqlDriverPlugin*, intptr_t, struct miqt_string);
+bool miqt_exec_callback_QSqlDriverPlugin_event(QSqlDriverPlugin*, intptr_t, QEvent*);
+bool miqt_exec_callback_QSqlDriverPlugin_eventFilter(QSqlDriverPlugin*, intptr_t, QObject*, QEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_timerEvent(QSqlDriverPlugin*, intptr_t, QTimerEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_childEvent(QSqlDriverPlugin*, intptr_t, QChildEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_customEvent(QSqlDriverPlugin*, intptr_t, QEvent*);
+void miqt_exec_callback_QSqlDriverPlugin_connectNotify(QSqlDriverPlugin*, intptr_t, QMetaMethod*);
+void miqt_exec_callback_QSqlDriverPlugin_disconnectNotify(QSqlDriverPlugin*, intptr_t, QMetaMethod*);
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+class MiqtVirtualQSqlDriverPlugin final : public QSqlDriverPlugin {
+public:
+
+	MiqtVirtualQSqlDriverPlugin(): QSqlDriverPlugin() {}
+	MiqtVirtualQSqlDriverPlugin(QObject* parent): QSqlDriverPlugin(parent) {}
+
+	virtual ~MiqtVirtualQSqlDriverPlugin() override = default;
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__create = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual QSqlDriver* create(const QString& key) override {
+		if (handle__create == 0) {
+			return nullptr; // Pure virtual, there is no base we can call
+		}
+
+		const QString key_ret = key;
+		// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+		QByteArray key_b = key_ret.toUtf8();
+		struct miqt_string key_ms;
+		key_ms.len = key_b.length();
+		key_ms.data = static_cast<char*>(malloc(key_ms.len));
+		memcpy(key_ms.data, key_b.data(), key_ms.len);
+		struct miqt_string sigval1 = key_ms;
+		QSqlDriver* callback_return_value = miqt_exec_callback_QSqlDriverPlugin_create(this, handle__create, sigval1);
+		return callback_return_value;
+	}
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__event = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool event(QEvent* event) override {
+		if (handle__event == 0) {
+			return QSqlDriverPlugin::event(event);
+		}
+
+		QEvent* sigval1 = event;
+		bool callback_return_value = miqt_exec_callback_QSqlDriverPlugin_event(this, handle__event, sigval1);
+		return callback_return_value;
+	}
+
+	friend bool QSqlDriverPlugin_virtualbase_event(void* self, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__eventFilter = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual bool eventFilter(QObject* watched, QEvent* event) override {
+		if (handle__eventFilter == 0) {
+			return QSqlDriverPlugin::eventFilter(watched, event);
+		}
+
+		QObject* sigval1 = watched;
+		QEvent* sigval2 = event;
+		bool callback_return_value = miqt_exec_callback_QSqlDriverPlugin_eventFilter(this, handle__eventFilter, sigval1, sigval2);
+		return callback_return_value;
+	}
+
+	friend bool QSqlDriverPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__timerEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void timerEvent(QTimerEvent* event) override {
+		if (handle__timerEvent == 0) {
+			QSqlDriverPlugin::timerEvent(event);
+			return;
+		}
+
+		QTimerEvent* sigval1 = event;
+		miqt_exec_callback_QSqlDriverPlugin_timerEvent(this, handle__timerEvent, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__childEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void childEvent(QChildEvent* event) override {
+		if (handle__childEvent == 0) {
+			QSqlDriverPlugin::childEvent(event);
+			return;
+		}
+
+		QChildEvent* sigval1 = event;
+		miqt_exec_callback_QSqlDriverPlugin_childEvent(this, handle__childEvent, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_childEvent(void* self, QChildEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__customEvent = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void customEvent(QEvent* event) override {
+		if (handle__customEvent == 0) {
+			QSqlDriverPlugin::customEvent(event);
+			return;
+		}
+
+		QEvent* sigval1 = event;
+		miqt_exec_callback_QSqlDriverPlugin_customEvent(this, handle__customEvent, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_customEvent(void* self, QEvent* event);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__connectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void connectNotify(const QMetaMethod& signal) override {
+		if (handle__connectNotify == 0) {
+			QSqlDriverPlugin::connectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QSqlDriverPlugin_connectNotify(this, handle__connectNotify, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+
+	// cgo.Handle value for overwritten implementation
+	intptr_t handle__disconnectNotify = 0;
+
+	// Subclass to allow providing a Go implementation
+	virtual void disconnectNotify(const QMetaMethod& signal) override {
+		if (handle__disconnectNotify == 0) {
+			QSqlDriverPlugin::disconnectNotify(signal);
+			return;
+		}
+
+		const QMetaMethod& signal_ret = signal;
+		// Cast returned reference into pointer
+		QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
+		miqt_exec_callback_QSqlDriverPlugin_disconnectNotify(this, handle__disconnectNotify, sigval1);
+
+	}
+
+	friend void QSqlDriverPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+	// Wrappers to allow calling protected methods:
+	friend QObject* QSqlDriverPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+	friend int QSqlDriverPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+	friend int QSqlDriverPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+	friend bool QSqlDriverPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+};
+
+QSqlDriverPlugin* QSqlDriverPlugin_new() {
+	return new (std::nothrow) MiqtVirtualQSqlDriverPlugin();
+}
+
+QSqlDriverPlugin* QSqlDriverPlugin_new2(QObject* parent) {
+	return new (std::nothrow) MiqtVirtualQSqlDriverPlugin(parent);
+}
+
+void QSqlDriverPlugin_virtbase(QSqlDriverPlugin* src, QObject** outptr_QObject) {
+	*outptr_QObject = static_cast<QObject*>(src);
+}
+
+QMetaObject* QSqlDriverPlugin_metaObject(const QSqlDriverPlugin* self) {
+	return (QMetaObject*) self->metaObject();
+}
+
+void* QSqlDriverPlugin_metacast(QSqlDriverPlugin* self, const char* param1) {
+	return self->qt_metacast(param1);
+}
+
+struct miqt_string QSqlDriverPlugin_tr(const char* s) {
+	QString _ret = QSqlDriverPlugin::tr(s);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QSqlDriver* QSqlDriverPlugin_create(QSqlDriverPlugin* self, struct miqt_string key) {
+	QString key_QString = QString::fromUtf8(key.data, key.len);
+	return self->create(key_QString);
+}
+
+struct miqt_string QSqlDriverPlugin_tr2(const char* s, const char* c) {
+	QString _ret = QSqlDriverPlugin::tr(s, c);
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlDriverPlugin_tr3(const char* s, const char* c, int n) {
+	QString _ret = QSqlDriverPlugin::tr(s, c, static_cast<int>(n));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QSqlDriverPlugin_override_virtual_create(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__create = slot;
+	return true;
+}
+
+bool QSqlDriverPlugin_override_virtual_event(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__event = slot;
+	return true;
+}
+
+bool QSqlDriverPlugin_virtualbase_event(void* self, QEvent* event) {
+	return static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::event(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_eventFilter(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__eventFilter = slot;
+	return true;
+}
+
+bool QSqlDriverPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
+	return static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::eventFilter(watched, event);
+}
+
+bool QSqlDriverPlugin_override_virtual_timerEvent(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__timerEvent = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::timerEvent(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_childEvent(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__childEvent = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_childEvent(void* self, QChildEvent* event) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::childEvent(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_customEvent(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__customEvent = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_customEvent(void* self, QEvent* event) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::customEvent(event);
+}
+
+bool QSqlDriverPlugin_override_virtual_connectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__connectNotify = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::connectNotify(*signal);
+}
+
+bool QSqlDriverPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		return false;
+	}
+
+	self_cast->handle__disconnectNotify = slot;
+	return true;
+}
+
+void QSqlDriverPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
+	static_cast<MiqtVirtualQSqlDriverPlugin*>(self)->QSqlDriverPlugin::disconnectNotify(*signal);
+}
+
+QObject* QSqlDriverPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return nullptr;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->sender();
+}
+
+int QSqlDriverPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->senderSignalIndex();
+}
+
+int QSqlDriverPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return 0;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->receivers(signal);
+}
+
+bool QSqlDriverPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) {
+	MiqtVirtualQSqlDriverPlugin* self_cast = dynamic_cast<MiqtVirtualQSqlDriverPlugin*>( (QSqlDriverPlugin*)(self) );
+	if (self_cast == nullptr) {
+		*_dynamic_cast_ok = false;
+		return false;
+	}
+
+	*_dynamic_cast_ok = true;
+	return self_cast->isSignalConnected(*signal);
+}
+
+void QSqlDriverPlugin_delete(QSqlDriverPlugin* self) {
+	delete self;
+}
+

qt6/sql/gen_qsqldriverplugin.go

@@ -0,0 +1,398 @@
+package sql
+
+/*
+
+#include "gen_qsqldriverplugin.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt6"
+	"runtime"
+	"runtime/cgo"
+	"unsafe"
+)
+
+type QSqlDriverPlugin struct {
+	h *C.QSqlDriverPlugin
+	*qt6.QObject
+}
+
+func (this *QSqlDriverPlugin) cPointer() *C.QSqlDriverPlugin {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlDriverPlugin) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlDriverPlugin constructs the type using only CGO pointers.
+func newQSqlDriverPlugin(h *C.QSqlDriverPlugin) *QSqlDriverPlugin {
+	if h == nil {
+		return nil
+	}
+	var outptr_QObject *C.QObject = nil
+	C.QSqlDriverPlugin_virtbase(h, &outptr_QObject)
+
+	return &QSqlDriverPlugin{h: h,
+		QObject: qt6.UnsafeNewQObject(unsafe.Pointer(outptr_QObject))}
+}
+
+// UnsafeNewQSqlDriverPlugin constructs the type using only unsafe pointers.
+func UnsafeNewQSqlDriverPlugin(h unsafe.Pointer) *QSqlDriverPlugin {
+	return newQSqlDriverPlugin((*C.QSqlDriverPlugin)(h))
+}
+
+// NewQSqlDriverPlugin constructs a new QSqlDriverPlugin object.
+func NewQSqlDriverPlugin() *QSqlDriverPlugin {
+
+	return newQSqlDriverPlugin(C.QSqlDriverPlugin_new())
+}
+
+// NewQSqlDriverPlugin2 constructs a new QSqlDriverPlugin object.
+func NewQSqlDriverPlugin2(parent *qt6.QObject) *QSqlDriverPlugin {
+
+	return newQSqlDriverPlugin(C.QSqlDriverPlugin_new2((*C.QObject)(parent.UnsafePointer())))
+}
+
+func (this *QSqlDriverPlugin) MetaObject() *qt6.QMetaObject {
+	return qt6.UnsafeNewQMetaObject(unsafe.Pointer(C.QSqlDriverPlugin_metaObject(this.h)))
+}
+
+func (this *QSqlDriverPlugin) Metacast(param1 string) unsafe.Pointer {
+	param1_Cstring := C.CString(param1)
+	defer C.free(unsafe.Pointer(param1_Cstring))
+	return (unsafe.Pointer)(C.QSqlDriverPlugin_metacast(this.h, param1_Cstring))
+}
+
+func QSqlDriverPlugin_Tr(s string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_tr(s_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlDriverPlugin) Create(key string) *QSqlDriver {
+	key_ms := C.struct_miqt_string{}
+	key_ms.data = C.CString(key)
+	key_ms.len = C.size_t(len(key))
+	defer C.free(unsafe.Pointer(key_ms.data))
+	return newQSqlDriver(C.QSqlDriverPlugin_create(this.h, key_ms))
+}
+
+func QSqlDriverPlugin_Tr2(s string, c string) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_tr2(s_Cstring, c_Cstring)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func QSqlDriverPlugin_Tr3(s string, c string, n int) string {
+	s_Cstring := C.CString(s)
+	defer C.free(unsafe.Pointer(s_Cstring))
+	c_Cstring := C.CString(c)
+	defer C.free(unsafe.Pointer(c_Cstring))
+	var _ms C.struct_miqt_string = C.QSqlDriverPlugin_tr3(s_Cstring, c_Cstring, (C.int)(n))
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+// Sender can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) Sender() *qt6.QObject {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := qt6.UnsafeNewQObject(unsafe.Pointer(C.QSqlDriverPlugin_protectedbase_sender(&_dynamic_cast_ok, unsafe.Pointer(this.h))))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// SenderSignalIndex can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) SenderSignalIndex() int {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QSqlDriverPlugin_protectedbase_senderSignalIndex(&_dynamic_cast_ok, unsafe.Pointer(this.h)))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// Receivers can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) Receivers(signal string) int {
+	signal_Cstring := C.CString(signal)
+	defer C.free(unsafe.Pointer(signal_Cstring))
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (int)(C.QSqlDriverPlugin_protectedbase_receivers(&_dynamic_cast_ok, unsafe.Pointer(this.h), signal_Cstring))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+
+// IsSignalConnected can only be called from a QSqlDriverPlugin that was directly constructed.
+func (this *QSqlDriverPlugin) IsSignalConnected(signal *qt6.QMetaMethod) bool {
+
+	var _dynamic_cast_ok C.bool = false
+	_method_ret := (bool)(C.QSqlDriverPlugin_protectedbase_isSignalConnected(&_dynamic_cast_ok, unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer())))
+
+	if !_dynamic_cast_ok {
+		panic("miqt: can only call protected methods for directly constructed types")
+	}
+
+	return _method_ret
+
+}
+func (this *QSqlDriverPlugin) OnCreate(slot func(key string) *QSqlDriver) {
+	ok := C.QSqlDriverPlugin_override_virtual_create(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_create
+func miqt_exec_callback_QSqlDriverPlugin_create(self *C.QSqlDriverPlugin, cb C.intptr_t, key C.struct_miqt_string) *C.QSqlDriver {
+	gofunc, ok := cgo.Handle(cb).Value().(func(key string) *QSqlDriver)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	var key_ms C.struct_miqt_string = key
+	key_ret := C.GoStringN(key_ms.data, C.int(int64(key_ms.len)))
+	C.free(unsafe.Pointer(key_ms.data))
+	slotval1 := key_ret
+
+	virtualReturn := gofunc(slotval1)
+
+	return virtualReturn.cPointer()
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_Event(event *qt6.QEvent) bool {
+
+	return (bool)(C.QSqlDriverPlugin_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QSqlDriverPlugin) OnEvent(slot func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool) {
+	ok := C.QSqlDriverPlugin_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_event
+func miqt_exec_callback_QSqlDriverPlugin_event(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent) bool, event *qt6.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_Event, slotval1)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_EventFilter(watched *qt6.QObject, event *qt6.QEvent) bool {
+
+	return (bool)(C.QSqlDriverPlugin_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer())))
+
+}
+func (this *QSqlDriverPlugin) OnEventFilter(slot func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool) {
+	ok := C.QSqlDriverPlugin_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_eventFilter
+func miqt_exec_callback_QSqlDriverPlugin_eventFilter(self *C.QSqlDriverPlugin, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt6.QObject, event *qt6.QEvent) bool, watched *qt6.QObject, event *qt6.QEvent) bool)
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQObject(unsafe.Pointer(watched))
+
+	slotval2 := qt6.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	virtualReturn := gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
+
+	return (C.bool)(virtualReturn)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_TimerEvent(event *qt6.QTimerEvent) {
+
+	C.QSqlDriverPlugin_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnTimerEvent(slot func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent)) {
+	ok := C.QSqlDriverPlugin_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_timerEvent
+func miqt_exec_callback_QSqlDriverPlugin_timerEvent(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QTimerEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QTimerEvent), event *qt6.QTimerEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQTimerEvent(unsafe.Pointer(event))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_TimerEvent, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_ChildEvent(event *qt6.QChildEvent) {
+
+	C.QSqlDriverPlugin_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnChildEvent(slot func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent)) {
+	ok := C.QSqlDriverPlugin_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_childEvent
+func miqt_exec_callback_QSqlDriverPlugin_childEvent(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QChildEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QChildEvent), event *qt6.QChildEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQChildEvent(unsafe.Pointer(event))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_ChildEvent, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_CustomEvent(event *qt6.QEvent) {
+
+	C.QSqlDriverPlugin_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnCustomEvent(slot func(super func(event *qt6.QEvent), event *qt6.QEvent)) {
+	ok := C.QSqlDriverPlugin_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_customEvent
+func miqt_exec_callback_QSqlDriverPlugin_customEvent(self *C.QSqlDriverPlugin, cb C.intptr_t, event *C.QEvent) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt6.QEvent), event *qt6.QEvent))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQEvent(unsafe.Pointer(event))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_CustomEvent, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_ConnectNotify(signal *qt6.QMetaMethod) {
+
+	C.QSqlDriverPlugin_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnConnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) {
+	ok := C.QSqlDriverPlugin_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_connectNotify
+func miqt_exec_callback_QSqlDriverPlugin_connectNotify(self *C.QSqlDriverPlugin, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_ConnectNotify, slotval1)
+
+}
+
+func (this *QSqlDriverPlugin) callVirtualBase_DisconnectNotify(signal *qt6.QMetaMethod) {
+
+	C.QSqlDriverPlugin_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
+
+}
+func (this *QSqlDriverPlugin) OnDisconnectNotify(slot func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod)) {
+	ok := C.QSqlDriverPlugin_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
+	if !ok {
+		panic("miqt: can only override virtual methods for directly constructed types")
+	}
+}
+
+//export miqt_exec_callback_QSqlDriverPlugin_disconnectNotify
+func miqt_exec_callback_QSqlDriverPlugin_disconnectNotify(self *C.QSqlDriverPlugin, cb C.intptr_t, signal *C.QMetaMethod) {
+	gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt6.QMetaMethod), signal *qt6.QMetaMethod))
+	if !ok {
+		panic("miqt: callback of non-callback type (heap corruption?)")
+	}
+
+	// Convert all CABI parameters to Go parameters
+	slotval1 := qt6.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
+
+	gofunc((&QSqlDriverPlugin{h: self}).callVirtualBase_DisconnectNotify, slotval1)
+
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlDriverPlugin) Delete() {
+	C.QSqlDriverPlugin_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlDriverPlugin) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlDriverPlugin) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt6/sql/gen_qsqldriverplugin.h

@@ -0,0 +1,75 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLDRIVERPLUGIN_H
+#define MIQT_QT6_SQL_GEN_QSQLDRIVERPLUGIN_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QChildEvent;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QObject;
+class QSqlDriver;
+class QSqlDriverPlugin;
+class QTimerEvent;
+#else
+typedef struct QChildEvent QChildEvent;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QObject QObject;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlDriverPlugin QSqlDriverPlugin;
+typedef struct QTimerEvent QTimerEvent;
+#endif
+
+QSqlDriverPlugin* QSqlDriverPlugin_new();
+QSqlDriverPlugin* QSqlDriverPlugin_new2(QObject* parent);
+void QSqlDriverPlugin_virtbase(QSqlDriverPlugin* src, QObject** outptr_QObject);
+QMetaObject* QSqlDriverPlugin_metaObject(const QSqlDriverPlugin* self);
+void* QSqlDriverPlugin_metacast(QSqlDriverPlugin* self, const char* param1);
+struct miqt_string QSqlDriverPlugin_tr(const char* s);
+QSqlDriver* QSqlDriverPlugin_create(QSqlDriverPlugin* self, struct miqt_string key);
+struct miqt_string QSqlDriverPlugin_tr2(const char* s, const char* c);
+struct miqt_string QSqlDriverPlugin_tr3(const char* s, const char* c, int n);
+
+bool QSqlDriverPlugin_override_virtual_create(void* self, intptr_t slot);
+QSqlDriver* QSqlDriverPlugin_virtualbase_create(void* self, struct miqt_string key);
+bool QSqlDriverPlugin_override_virtual_event(void* self, intptr_t slot);
+bool QSqlDriverPlugin_virtualbase_event(void* self, QEvent* event);
+bool QSqlDriverPlugin_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlDriverPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlDriverPlugin_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlDriverPlugin_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlDriverPlugin_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlDriverPlugin_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlDriverPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlDriverPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+QObject* QSqlDriverPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriverPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlDriverPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlDriverPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlDriverPlugin_delete(QSqlDriverPlugin* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqlerror.cpp

@@ -0,0 +1,120 @@
+#include <QSqlError>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qsqlerror.h>
+#include "gen_qsqlerror.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlError* QSqlError_new() {
+	return new (std::nothrow) QSqlError();
+}
+
+QSqlError* QSqlError_new2(QSqlError* other) {
+	return new (std::nothrow) QSqlError(*other);
+}
+
+QSqlError* QSqlError_new3(struct miqt_string driverText) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	return new (std::nothrow) QSqlError(driverText_QString);
+}
+
+QSqlError* QSqlError_new4(struct miqt_string driverText, struct miqt_string databaseText) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	return new (std::nothrow) QSqlError(driverText_QString, databaseText_QString);
+}
+
+QSqlError* QSqlError_new5(struct miqt_string driverText, struct miqt_string databaseText, int type) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	return new (std::nothrow) QSqlError(driverText_QString, databaseText_QString, static_cast<QSqlError::ErrorType>(type));
+}
+
+QSqlError* QSqlError_new6(struct miqt_string driverText, struct miqt_string databaseText, int type, struct miqt_string errorCode) {
+	QString driverText_QString = QString::fromUtf8(driverText.data, driverText.len);
+	QString databaseText_QString = QString::fromUtf8(databaseText.data, databaseText.len);
+	QString errorCode_QString = QString::fromUtf8(errorCode.data, errorCode.len);
+	return new (std::nothrow) QSqlError(driverText_QString, databaseText_QString, static_cast<QSqlError::ErrorType>(type), errorCode_QString);
+}
+
+void QSqlError_operatorAssign(QSqlError* self, QSqlError* other) {
+	self->operator=(*other);
+}
+
+bool QSqlError_operatorEqual(const QSqlError* self, QSqlError* other) {
+	return (*self == *other);
+}
+
+bool QSqlError_operatorNotEqual(const QSqlError* self, QSqlError* other) {
+	return (*self != *other);
+}
+
+void QSqlError_swap(QSqlError* self, QSqlError* other) {
+	self->swap(*other);
+}
+
+struct miqt_string QSqlError_driverText(const QSqlError* self) {
+	QString _ret = self->driverText();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlError_databaseText(const QSqlError* self) {
+	QString _ret = self->databaseText();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QSqlError_type(const QSqlError* self) {
+	QSqlError::ErrorType _ret = self->type();
+	return static_cast<int>(_ret);
+}
+
+struct miqt_string QSqlError_nativeErrorCode(const QSqlError* self) {
+	QString _ret = self->nativeErrorCode();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+struct miqt_string QSqlError_text(const QSqlError* self) {
+	QString _ret = self->text();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QSqlError_isValid(const QSqlError* self) {
+	return self->isValid();
+}
+
+void QSqlError_delete(QSqlError* self) {
+	delete self;
+}
+

qt6/sql/gen_qsqlerror.go

@@ -0,0 +1,190 @@
+package sql
+
+/*
+
+#include "gen_qsqlerror.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSqlError__ErrorType int
+
+const (
+	QSqlError__NoError          QSqlError__ErrorType = 0
+	QSqlError__ConnectionError  QSqlError__ErrorType = 1
+	QSqlError__StatementError   QSqlError__ErrorType = 2
+	QSqlError__TransactionError QSqlError__ErrorType = 3
+	QSqlError__UnknownError     QSqlError__ErrorType = 4
+)
+
+type QSqlError struct {
+	h *C.QSqlError
+}
+
+func (this *QSqlError) cPointer() *C.QSqlError {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlError) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlError constructs the type using only CGO pointers.
+func newQSqlError(h *C.QSqlError) *QSqlError {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlError{h: h}
+}
+
+// UnsafeNewQSqlError constructs the type using only unsafe pointers.
+func UnsafeNewQSqlError(h unsafe.Pointer) *QSqlError {
+	return newQSqlError((*C.QSqlError)(h))
+}
+
+// NewQSqlError constructs a new QSqlError object.
+func NewQSqlError() *QSqlError {
+
+	return newQSqlError(C.QSqlError_new())
+}
+
+// NewQSqlError2 constructs a new QSqlError object.
+func NewQSqlError2(other *QSqlError) *QSqlError {
+
+	return newQSqlError(C.QSqlError_new2(other.cPointer()))
+}
+
+// NewQSqlError3 constructs a new QSqlError object.
+func NewQSqlError3(driverText string) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+
+	return newQSqlError(C.QSqlError_new3(driverText_ms))
+}
+
+// NewQSqlError4 constructs a new QSqlError object.
+func NewQSqlError4(driverText string, databaseText string) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+
+	return newQSqlError(C.QSqlError_new4(driverText_ms, databaseText_ms))
+}
+
+// NewQSqlError5 constructs a new QSqlError object.
+func NewQSqlError5(driverText string, databaseText string, typeVal QSqlError__ErrorType) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+
+	return newQSqlError(C.QSqlError_new5(driverText_ms, databaseText_ms, (C.int)(typeVal)))
+}
+
+// NewQSqlError6 constructs a new QSqlError object.
+func NewQSqlError6(driverText string, databaseText string, typeVal QSqlError__ErrorType, errorCode string) *QSqlError {
+	driverText_ms := C.struct_miqt_string{}
+	driverText_ms.data = C.CString(driverText)
+	driverText_ms.len = C.size_t(len(driverText))
+	defer C.free(unsafe.Pointer(driverText_ms.data))
+	databaseText_ms := C.struct_miqt_string{}
+	databaseText_ms.data = C.CString(databaseText)
+	databaseText_ms.len = C.size_t(len(databaseText))
+	defer C.free(unsafe.Pointer(databaseText_ms.data))
+	errorCode_ms := C.struct_miqt_string{}
+	errorCode_ms.data = C.CString(errorCode)
+	errorCode_ms.len = C.size_t(len(errorCode))
+	defer C.free(unsafe.Pointer(errorCode_ms.data))
+
+	return newQSqlError(C.QSqlError_new6(driverText_ms, databaseText_ms, (C.int)(typeVal), errorCode_ms))
+}
+
+func (this *QSqlError) OperatorAssign(other *QSqlError) {
+	C.QSqlError_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlError) OperatorEqual(other *QSqlError) bool {
+	return (bool)(C.QSqlError_operatorEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlError) OperatorNotEqual(other *QSqlError) bool {
+	return (bool)(C.QSqlError_operatorNotEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlError) Swap(other *QSqlError) {
+	C.QSqlError_swap(this.h, other.cPointer())
+}
+
+func (this *QSqlError) DriverText() string {
+	var _ms C.struct_miqt_string = C.QSqlError_driverText(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) DatabaseText() string {
+	var _ms C.struct_miqt_string = C.QSqlError_databaseText(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) Type() QSqlError__ErrorType {
+	return (QSqlError__ErrorType)(C.QSqlError_type(this.h))
+}
+
+func (this *QSqlError) NativeErrorCode() string {
+	var _ms C.struct_miqt_string = C.QSqlError_nativeErrorCode(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) Text() string {
+	var _ms C.struct_miqt_string = C.QSqlError_text(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlError) IsValid() bool {
+	return (bool)(C.QSqlError_isValid(this.h))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlError) Delete() {
+	C.QSqlError_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlError) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlError) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt6/sql/gen_qsqlerror.h

@@ -0,0 +1,46 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLERROR_H
+#define MIQT_QT6_SQL_GEN_QSQLERROR_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlError;
+#else
+typedef struct QSqlError QSqlError;
+#endif
+
+QSqlError* QSqlError_new();
+QSqlError* QSqlError_new2(QSqlError* other);
+QSqlError* QSqlError_new3(struct miqt_string driverText);
+QSqlError* QSqlError_new4(struct miqt_string driverText, struct miqt_string databaseText);
+QSqlError* QSqlError_new5(struct miqt_string driverText, struct miqt_string databaseText, int type);
+QSqlError* QSqlError_new6(struct miqt_string driverText, struct miqt_string databaseText, int type, struct miqt_string errorCode);
+void QSqlError_operatorAssign(QSqlError* self, QSqlError* other);
+bool QSqlError_operatorEqual(const QSqlError* self, QSqlError* other);
+bool QSqlError_operatorNotEqual(const QSqlError* self, QSqlError* other);
+void QSqlError_swap(QSqlError* self, QSqlError* other);
+struct miqt_string QSqlError_driverText(const QSqlError* self);
+struct miqt_string QSqlError_databaseText(const QSqlError* self);
+int QSqlError_type(const QSqlError* self);
+struct miqt_string QSqlError_nativeErrorCode(const QSqlError* self);
+struct miqt_string QSqlError_text(const QSqlError* self);
+bool QSqlError_isValid(const QSqlError* self);
+
+void QSqlError_delete(QSqlError* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqlfield.cpp

@@ -0,0 +1,206 @@
+#include <QMetaType>
+#include <QSqlField>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QVariant>
+#include <qsqlfield.h>
+#include "gen_qsqlfield.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlField* QSqlField_new() {
+	return new (std::nothrow) QSqlField();
+}
+
+QSqlField* QSqlField_new2(QSqlField* other) {
+	return new (std::nothrow) QSqlField(*other);
+}
+
+QSqlField* QSqlField_new3(struct miqt_string fieldName, int type) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString, static_cast<QVariant::Type>(type));
+}
+
+QSqlField* QSqlField_new4(struct miqt_string fieldName) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString);
+}
+
+QSqlField* QSqlField_new5(struct miqt_string fieldName, QMetaType* type) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString, *type);
+}
+
+QSqlField* QSqlField_new6(struct miqt_string fieldName, QMetaType* type, struct miqt_string tableName) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	QString tableName_QString = QString::fromUtf8(tableName.data, tableName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString, *type, tableName_QString);
+}
+
+QSqlField* QSqlField_new7(struct miqt_string fieldName, int type, struct miqt_string tableName) {
+	QString fieldName_QString = QString::fromUtf8(fieldName.data, fieldName.len);
+	QString tableName_QString = QString::fromUtf8(tableName.data, tableName.len);
+	return new (std::nothrow) QSqlField(fieldName_QString, static_cast<QVariant::Type>(type), tableName_QString);
+}
+
+void QSqlField_operatorAssign(QSqlField* self, QSqlField* other) {
+	self->operator=(*other);
+}
+
+bool QSqlField_operatorEqual(const QSqlField* self, QSqlField* other) {
+	return (*self == *other);
+}
+
+bool QSqlField_operatorNotEqual(const QSqlField* self, QSqlField* other) {
+	return (*self != *other);
+}
+
+void QSqlField_setValue(QSqlField* self, QVariant* value) {
+	self->setValue(*value);
+}
+
+QVariant* QSqlField_value(const QSqlField* self) {
+	return new QVariant(self->value());
+}
+
+void QSqlField_setName(QSqlField* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setName(name_QString);
+}
+
+struct miqt_string QSqlField_name(const QSqlField* self) {
+	QString _ret = self->name();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlField_setTableName(QSqlField* self, struct miqt_string tableName) {
+	QString tableName_QString = QString::fromUtf8(tableName.data, tableName.len);
+	self->setTableName(tableName_QString);
+}
+
+struct miqt_string QSqlField_tableName(const QSqlField* self) {
+	QString _ret = self->tableName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+bool QSqlField_isNull(const QSqlField* self) {
+	return self->isNull();
+}
+
+void QSqlField_setReadOnly(QSqlField* self, bool readOnly) {
+	self->setReadOnly(readOnly);
+}
+
+bool QSqlField_isReadOnly(const QSqlField* self) {
+	return self->isReadOnly();
+}
+
+void QSqlField_clear(QSqlField* self) {
+	self->clear();
+}
+
+bool QSqlField_isAutoValue(const QSqlField* self) {
+	return self->isAutoValue();
+}
+
+QMetaType* QSqlField_metaType(const QSqlField* self) {
+	return new QMetaType(self->metaType());
+}
+
+void QSqlField_setMetaType(QSqlField* self, QMetaType* type) {
+	self->setMetaType(*type);
+}
+
+int QSqlField_type(const QSqlField* self) {
+	QVariant::Type _ret = self->type();
+	return static_cast<int>(_ret);
+}
+
+void QSqlField_setType(QSqlField* self, int type) {
+	self->setType(static_cast<QVariant::Type>(type));
+}
+
+void QSqlField_setRequiredStatus(QSqlField* self, int status) {
+	self->setRequiredStatus(static_cast<QSqlField::RequiredStatus>(status));
+}
+
+void QSqlField_setRequired(QSqlField* self, bool required) {
+	self->setRequired(required);
+}
+
+void QSqlField_setLength(QSqlField* self, int fieldLength) {
+	self->setLength(static_cast<int>(fieldLength));
+}
+
+void QSqlField_setPrecision(QSqlField* self, int precision) {
+	self->setPrecision(static_cast<int>(precision));
+}
+
+void QSqlField_setDefaultValue(QSqlField* self, QVariant* value) {
+	self->setDefaultValue(*value);
+}
+
+void QSqlField_setSqlType(QSqlField* self, int type) {
+	self->setSqlType(static_cast<int>(type));
+}
+
+void QSqlField_setGenerated(QSqlField* self, bool gen) {
+	self->setGenerated(gen);
+}
+
+void QSqlField_setAutoValue(QSqlField* self, bool autoVal) {
+	self->setAutoValue(autoVal);
+}
+
+int QSqlField_requiredStatus(const QSqlField* self) {
+	QSqlField::RequiredStatus _ret = self->requiredStatus();
+	return static_cast<int>(_ret);
+}
+
+int QSqlField_length(const QSqlField* self) {
+	return self->length();
+}
+
+int QSqlField_precision(const QSqlField* self) {
+	return self->precision();
+}
+
+QVariant* QSqlField_defaultValue(const QSqlField* self) {
+	return new QVariant(self->defaultValue());
+}
+
+int QSqlField_typeID(const QSqlField* self) {
+	return self->typeID();
+}
+
+bool QSqlField_isGenerated(const QSqlField* self) {
+	return self->isGenerated();
+}
+
+bool QSqlField_isValid(const QSqlField* self) {
+	return self->isValid();
+}
+
+void QSqlField_delete(QSqlField* self) {
+	delete self;
+}
+

qt6/sql/gen_qsqlfield.go

@@ -0,0 +1,291 @@
+package sql
+
+/*
+
+#include "gen_qsqlfield.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt6"
+	"runtime"
+	"unsafe"
+)
+
+type QSqlField__RequiredStatus int
+
+const (
+	QSqlField__Unknown  QSqlField__RequiredStatus = -1
+	QSqlField__Optional QSqlField__RequiredStatus = 0
+	QSqlField__Required QSqlField__RequiredStatus = 1
+)
+
+type QSqlField struct {
+	h *C.QSqlField
+}
+
+func (this *QSqlField) cPointer() *C.QSqlField {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlField) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlField constructs the type using only CGO pointers.
+func newQSqlField(h *C.QSqlField) *QSqlField {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlField{h: h}
+}
+
+// UnsafeNewQSqlField constructs the type using only unsafe pointers.
+func UnsafeNewQSqlField(h unsafe.Pointer) *QSqlField {
+	return newQSqlField((*C.QSqlField)(h))
+}
+
+// NewQSqlField constructs a new QSqlField object.
+func NewQSqlField() *QSqlField {
+
+	return newQSqlField(C.QSqlField_new())
+}
+
+// NewQSqlField2 constructs a new QSqlField object.
+func NewQSqlField2(other *QSqlField) *QSqlField {
+
+	return newQSqlField(C.QSqlField_new2(other.cPointer()))
+}
+
+// NewQSqlField3 constructs a new QSqlField object.
+func NewQSqlField3(fieldName string, typeVal qt6.QVariant__Type) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+
+	return newQSqlField(C.QSqlField_new3(fieldName_ms, (C.int)(typeVal)))
+}
+
+// NewQSqlField4 constructs a new QSqlField object.
+func NewQSqlField4(fieldName string) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+
+	return newQSqlField(C.QSqlField_new4(fieldName_ms))
+}
+
+// NewQSqlField5 constructs a new QSqlField object.
+func NewQSqlField5(fieldName string, typeVal qt6.QMetaType) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+
+	return newQSqlField(C.QSqlField_new5(fieldName_ms, (*C.QMetaType)(typeVal.UnsafePointer())))
+}
+
+// NewQSqlField6 constructs a new QSqlField object.
+func NewQSqlField6(fieldName string, typeVal qt6.QMetaType, tableName string) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+	tableName_ms := C.struct_miqt_string{}
+	tableName_ms.data = C.CString(tableName)
+	tableName_ms.len = C.size_t(len(tableName))
+	defer C.free(unsafe.Pointer(tableName_ms.data))
+
+	return newQSqlField(C.QSqlField_new6(fieldName_ms, (*C.QMetaType)(typeVal.UnsafePointer()), tableName_ms))
+}
+
+// NewQSqlField7 constructs a new QSqlField object.
+func NewQSqlField7(fieldName string, typeVal qt6.QVariant__Type, tableName string) *QSqlField {
+	fieldName_ms := C.struct_miqt_string{}
+	fieldName_ms.data = C.CString(fieldName)
+	fieldName_ms.len = C.size_t(len(fieldName))
+	defer C.free(unsafe.Pointer(fieldName_ms.data))
+	tableName_ms := C.struct_miqt_string{}
+	tableName_ms.data = C.CString(tableName)
+	tableName_ms.len = C.size_t(len(tableName))
+	defer C.free(unsafe.Pointer(tableName_ms.data))
+
+	return newQSqlField(C.QSqlField_new7(fieldName_ms, (C.int)(typeVal), tableName_ms))
+}
+
+func (this *QSqlField) OperatorAssign(other *QSqlField) {
+	C.QSqlField_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlField) OperatorEqual(other *QSqlField) bool {
+	return (bool)(C.QSqlField_operatorEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlField) OperatorNotEqual(other *QSqlField) bool {
+	return (bool)(C.QSqlField_operatorNotEqual(this.h, other.cPointer()))
+}
+
+func (this *QSqlField) SetValue(value *qt6.QVariant) {
+	C.QSqlField_setValue(this.h, (*C.QVariant)(value.UnsafePointer()))
+}
+
+func (this *QSqlField) Value() *qt6.QVariant {
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QSqlField_value(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlField) SetName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlField_setName(this.h, name_ms)
+}
+
+func (this *QSqlField) Name() string {
+	var _ms C.struct_miqt_string = C.QSqlField_name(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlField) SetTableName(tableName string) {
+	tableName_ms := C.struct_miqt_string{}
+	tableName_ms.data = C.CString(tableName)
+	tableName_ms.len = C.size_t(len(tableName))
+	defer C.free(unsafe.Pointer(tableName_ms.data))
+	C.QSqlField_setTableName(this.h, tableName_ms)
+}
+
+func (this *QSqlField) TableName() string {
+	var _ms C.struct_miqt_string = C.QSqlField_tableName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlField) IsNull() bool {
+	return (bool)(C.QSqlField_isNull(this.h))
+}
+
+func (this *QSqlField) SetReadOnly(readOnly bool) {
+	C.QSqlField_setReadOnly(this.h, (C.bool)(readOnly))
+}
+
+func (this *QSqlField) IsReadOnly() bool {
+	return (bool)(C.QSqlField_isReadOnly(this.h))
+}
+
+func (this *QSqlField) Clear() {
+	C.QSqlField_clear(this.h)
+}
+
+func (this *QSqlField) IsAutoValue() bool {
+	return (bool)(C.QSqlField_isAutoValue(this.h))
+}
+
+func (this *QSqlField) MetaType() *qt6.QMetaType {
+	_goptr := qt6.UnsafeNewQMetaType(unsafe.Pointer(C.QSqlField_metaType(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlField) SetMetaType(typeVal qt6.QMetaType) {
+	C.QSqlField_setMetaType(this.h, (*C.QMetaType)(typeVal.UnsafePointer()))
+}
+
+func (this *QSqlField) Type() qt6.QVariant__Type {
+	return (qt6.QVariant__Type)(C.QSqlField_type(this.h))
+}
+
+func (this *QSqlField) SetType(typeVal qt6.QVariant__Type) {
+	C.QSqlField_setType(this.h, (C.int)(typeVal))
+}
+
+func (this *QSqlField) SetRequiredStatus(status QSqlField__RequiredStatus) {
+	C.QSqlField_setRequiredStatus(this.h, (C.int)(status))
+}
+
+func (this *QSqlField) SetRequired(required bool) {
+	C.QSqlField_setRequired(this.h, (C.bool)(required))
+}
+
+func (this *QSqlField) SetLength(fieldLength int) {
+	C.QSqlField_setLength(this.h, (C.int)(fieldLength))
+}
+
+func (this *QSqlField) SetPrecision(precision int) {
+	C.QSqlField_setPrecision(this.h, (C.int)(precision))
+}
+
+func (this *QSqlField) SetDefaultValue(value *qt6.QVariant) {
+	C.QSqlField_setDefaultValue(this.h, (*C.QVariant)(value.UnsafePointer()))
+}
+
+func (this *QSqlField) SetSqlType(typeVal int) {
+	C.QSqlField_setSqlType(this.h, (C.int)(typeVal))
+}
+
+func (this *QSqlField) SetGenerated(gen bool) {
+	C.QSqlField_setGenerated(this.h, (C.bool)(gen))
+}
+
+func (this *QSqlField) SetAutoValue(autoVal bool) {
+	C.QSqlField_setAutoValue(this.h, (C.bool)(autoVal))
+}
+
+func (this *QSqlField) RequiredStatus() QSqlField__RequiredStatus {
+	return (QSqlField__RequiredStatus)(C.QSqlField_requiredStatus(this.h))
+}
+
+func (this *QSqlField) Length() int {
+	return (int)(C.QSqlField_length(this.h))
+}
+
+func (this *QSqlField) Precision() int {
+	return (int)(C.QSqlField_precision(this.h))
+}
+
+func (this *QSqlField) DefaultValue() *qt6.QVariant {
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QSqlField_defaultValue(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlField) TypeID() int {
+	return (int)(C.QSqlField_typeID(this.h))
+}
+
+func (this *QSqlField) IsGenerated() bool {
+	return (bool)(C.QSqlField_isGenerated(this.h))
+}
+
+func (this *QSqlField) IsValid() bool {
+	return (bool)(C.QSqlField_isValid(this.h))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlField) Delete() {
+	C.QSqlField_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlField) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlField) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt6/sql/gen_qsqlfield.h

@@ -0,0 +1,74 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLFIELD_H
+#define MIQT_QT6_SQL_GEN_QSQLFIELD_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QMetaType;
+class QSqlField;
+class QVariant;
+#else
+typedef struct QMetaType QMetaType;
+typedef struct QSqlField QSqlField;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlField* QSqlField_new();
+QSqlField* QSqlField_new2(QSqlField* other);
+QSqlField* QSqlField_new3(struct miqt_string fieldName, int type);
+QSqlField* QSqlField_new4(struct miqt_string fieldName);
+QSqlField* QSqlField_new5(struct miqt_string fieldName, QMetaType* type);
+QSqlField* QSqlField_new6(struct miqt_string fieldName, QMetaType* type, struct miqt_string tableName);
+QSqlField* QSqlField_new7(struct miqt_string fieldName, int type, struct miqt_string tableName);
+void QSqlField_operatorAssign(QSqlField* self, QSqlField* other);
+bool QSqlField_operatorEqual(const QSqlField* self, QSqlField* other);
+bool QSqlField_operatorNotEqual(const QSqlField* self, QSqlField* other);
+void QSqlField_setValue(QSqlField* self, QVariant* value);
+QVariant* QSqlField_value(const QSqlField* self);
+void QSqlField_setName(QSqlField* self, struct miqt_string name);
+struct miqt_string QSqlField_name(const QSqlField* self);
+void QSqlField_setTableName(QSqlField* self, struct miqt_string tableName);
+struct miqt_string QSqlField_tableName(const QSqlField* self);
+bool QSqlField_isNull(const QSqlField* self);
+void QSqlField_setReadOnly(QSqlField* self, bool readOnly);
+bool QSqlField_isReadOnly(const QSqlField* self);
+void QSqlField_clear(QSqlField* self);
+bool QSqlField_isAutoValue(const QSqlField* self);
+QMetaType* QSqlField_metaType(const QSqlField* self);
+void QSqlField_setMetaType(QSqlField* self, QMetaType* type);
+int QSqlField_type(const QSqlField* self);
+void QSqlField_setType(QSqlField* self, int type);
+void QSqlField_setRequiredStatus(QSqlField* self, int status);
+void QSqlField_setRequired(QSqlField* self, bool required);
+void QSqlField_setLength(QSqlField* self, int fieldLength);
+void QSqlField_setPrecision(QSqlField* self, int precision);
+void QSqlField_setDefaultValue(QSqlField* self, QVariant* value);
+void QSqlField_setSqlType(QSqlField* self, int type);
+void QSqlField_setGenerated(QSqlField* self, bool gen);
+void QSqlField_setAutoValue(QSqlField* self, bool autoVal);
+int QSqlField_requiredStatus(const QSqlField* self);
+int QSqlField_length(const QSqlField* self);
+int QSqlField_precision(const QSqlField* self);
+QVariant* QSqlField_defaultValue(const QSqlField* self);
+int QSqlField_typeID(const QSqlField* self);
+bool QSqlField_isGenerated(const QSqlField* self);
+bool QSqlField_isValid(const QSqlField* self);
+
+void QSqlField_delete(QSqlField* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqlindex.cpp

@@ -0,0 +1,96 @@
+#include <QSqlField>
+#include <QSqlIndex>
+#include <QSqlRecord>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <qsqlindex.h>
+#include "gen_qsqlindex.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlIndex* QSqlIndex_new() {
+	return new (std::nothrow) QSqlIndex();
+}
+
+QSqlIndex* QSqlIndex_new2(QSqlIndex* other) {
+	return new (std::nothrow) QSqlIndex(*other);
+}
+
+QSqlIndex* QSqlIndex_new3(struct miqt_string cursorName) {
+	QString cursorName_QString = QString::fromUtf8(cursorName.data, cursorName.len);
+	return new (std::nothrow) QSqlIndex(cursorName_QString);
+}
+
+QSqlIndex* QSqlIndex_new4(struct miqt_string cursorName, struct miqt_string name) {
+	QString cursorName_QString = QString::fromUtf8(cursorName.data, cursorName.len);
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new (std::nothrow) QSqlIndex(cursorName_QString, name_QString);
+}
+
+void QSqlIndex_virtbase(QSqlIndex* src, QSqlRecord** outptr_QSqlRecord) {
+	*outptr_QSqlRecord = static_cast<QSqlRecord*>(src);
+}
+
+void QSqlIndex_operatorAssign(QSqlIndex* self, QSqlIndex* other) {
+	self->operator=(*other);
+}
+
+void QSqlIndex_setCursorName(QSqlIndex* self, struct miqt_string cursorName) {
+	QString cursorName_QString = QString::fromUtf8(cursorName.data, cursorName.len);
+	self->setCursorName(cursorName_QString);
+}
+
+struct miqt_string QSqlIndex_cursorName(const QSqlIndex* self) {
+	QString _ret = self->cursorName();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlIndex_setName(QSqlIndex* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setName(name_QString);
+}
+
+struct miqt_string QSqlIndex_name(const QSqlIndex* self) {
+	QString _ret = self->name();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+void QSqlIndex_append(QSqlIndex* self, QSqlField* field) {
+	self->append(*field);
+}
+
+void QSqlIndex_append2(QSqlIndex* self, QSqlField* field, bool desc) {
+	self->append(*field, desc);
+}
+
+bool QSqlIndex_isDescending(const QSqlIndex* self, int i) {
+	return self->isDescending(static_cast<int>(i));
+}
+
+void QSqlIndex_setDescending(QSqlIndex* self, int i, bool desc) {
+	self->setDescending(static_cast<int>(i), desc);
+}
+
+void QSqlIndex_delete(QSqlIndex* self) {
+	delete self;
+}
+

qt6/sql/gen_qsqlindex.go

@@ -0,0 +1,150 @@
+package sql
+
+/*
+
+#include "gen_qsqlindex.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"runtime"
+	"unsafe"
+)
+
+type QSqlIndex struct {
+	h *C.QSqlIndex
+	*QSqlRecord
+}
+
+func (this *QSqlIndex) cPointer() *C.QSqlIndex {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlIndex) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlIndex constructs the type using only CGO pointers.
+func newQSqlIndex(h *C.QSqlIndex) *QSqlIndex {
+	if h == nil {
+		return nil
+	}
+	var outptr_QSqlRecord *C.QSqlRecord = nil
+	C.QSqlIndex_virtbase(h, &outptr_QSqlRecord)
+
+	return &QSqlIndex{h: h,
+		QSqlRecord: newQSqlRecord(outptr_QSqlRecord)}
+}
+
+// UnsafeNewQSqlIndex constructs the type using only unsafe pointers.
+func UnsafeNewQSqlIndex(h unsafe.Pointer) *QSqlIndex {
+	return newQSqlIndex((*C.QSqlIndex)(h))
+}
+
+// NewQSqlIndex constructs a new QSqlIndex object.
+func NewQSqlIndex() *QSqlIndex {
+
+	return newQSqlIndex(C.QSqlIndex_new())
+}
+
+// NewQSqlIndex2 constructs a new QSqlIndex object.
+func NewQSqlIndex2(other *QSqlIndex) *QSqlIndex {
+
+	return newQSqlIndex(C.QSqlIndex_new2(other.cPointer()))
+}
+
+// NewQSqlIndex3 constructs a new QSqlIndex object.
+func NewQSqlIndex3(cursorName string) *QSqlIndex {
+	cursorName_ms := C.struct_miqt_string{}
+	cursorName_ms.data = C.CString(cursorName)
+	cursorName_ms.len = C.size_t(len(cursorName))
+	defer C.free(unsafe.Pointer(cursorName_ms.data))
+
+	return newQSqlIndex(C.QSqlIndex_new3(cursorName_ms))
+}
+
+// NewQSqlIndex4 constructs a new QSqlIndex object.
+func NewQSqlIndex4(cursorName string, name string) *QSqlIndex {
+	cursorName_ms := C.struct_miqt_string{}
+	cursorName_ms.data = C.CString(cursorName)
+	cursorName_ms.len = C.size_t(len(cursorName))
+	defer C.free(unsafe.Pointer(cursorName_ms.data))
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+
+	return newQSqlIndex(C.QSqlIndex_new4(cursorName_ms, name_ms))
+}
+
+func (this *QSqlIndex) OperatorAssign(other *QSqlIndex) {
+	C.QSqlIndex_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlIndex) SetCursorName(cursorName string) {
+	cursorName_ms := C.struct_miqt_string{}
+	cursorName_ms.data = C.CString(cursorName)
+	cursorName_ms.len = C.size_t(len(cursorName))
+	defer C.free(unsafe.Pointer(cursorName_ms.data))
+	C.QSqlIndex_setCursorName(this.h, cursorName_ms)
+}
+
+func (this *QSqlIndex) CursorName() string {
+	var _ms C.struct_miqt_string = C.QSqlIndex_cursorName(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlIndex) SetName(name string) {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	C.QSqlIndex_setName(this.h, name_ms)
+}
+
+func (this *QSqlIndex) Name() string {
+	var _ms C.struct_miqt_string = C.QSqlIndex_name(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlIndex) Append(field *QSqlField) {
+	C.QSqlIndex_append(this.h, field.cPointer())
+}
+
+func (this *QSqlIndex) Append2(field *QSqlField, desc bool) {
+	C.QSqlIndex_append2(this.h, field.cPointer(), (C.bool)(desc))
+}
+
+func (this *QSqlIndex) IsDescending(i int) bool {
+	return (bool)(C.QSqlIndex_isDescending(this.h, (C.int)(i)))
+}
+
+func (this *QSqlIndex) SetDescending(i int, desc bool) {
+	C.QSqlIndex_setDescending(this.h, (C.int)(i), (C.bool)(desc))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlIndex) Delete() {
+	C.QSqlIndex_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlIndex) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlIndex) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt6/sql/gen_qsqlindex.h

@@ -0,0 +1,48 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLINDEX_H
+#define MIQT_QT6_SQL_GEN_QSQLINDEX_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlField;
+class QSqlIndex;
+class QSqlRecord;
+#else
+typedef struct QSqlField QSqlField;
+typedef struct QSqlIndex QSqlIndex;
+typedef struct QSqlRecord QSqlRecord;
+#endif
+
+QSqlIndex* QSqlIndex_new();
+QSqlIndex* QSqlIndex_new2(QSqlIndex* other);
+QSqlIndex* QSqlIndex_new3(struct miqt_string cursorName);
+QSqlIndex* QSqlIndex_new4(struct miqt_string cursorName, struct miqt_string name);
+void QSqlIndex_virtbase(QSqlIndex* src, QSqlRecord** outptr_QSqlRecord);
+void QSqlIndex_operatorAssign(QSqlIndex* self, QSqlIndex* other);
+void QSqlIndex_setCursorName(QSqlIndex* self, struct miqt_string cursorName);
+struct miqt_string QSqlIndex_cursorName(const QSqlIndex* self);
+void QSqlIndex_setName(QSqlIndex* self, struct miqt_string name);
+struct miqt_string QSqlIndex_name(const QSqlIndex* self);
+void QSqlIndex_append(QSqlIndex* self, QSqlField* field);
+void QSqlIndex_append2(QSqlIndex* self, QSqlField* field, bool desc);
+bool QSqlIndex_isDescending(const QSqlIndex* self, int i);
+void QSqlIndex_setDescending(QSqlIndex* self, int i, bool desc);
+
+void QSqlIndex_delete(QSqlIndex* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqlquery.cpp

@@ -0,0 +1,267 @@
+#include <QList>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QSqlError>
+#include <QSqlQuery>
+#include <QSqlRecord>
+#include <QSqlResult>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QVariant>
+#include <qsqlquery.h>
+#include "gen_qsqlquery.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlQuery* QSqlQuery_new(QSqlResult* r) {
+	return new (std::nothrow) QSqlQuery(r);
+}
+
+QSqlQuery* QSqlQuery_new2() {
+	return new (std::nothrow) QSqlQuery();
+}
+
+QSqlQuery* QSqlQuery_new3(QSqlDatabase* db) {
+	return new (std::nothrow) QSqlQuery(*db);
+}
+
+QSqlQuery* QSqlQuery_new4(QSqlQuery* other) {
+	return new (std::nothrow) QSqlQuery(*other);
+}
+
+QSqlQuery* QSqlQuery_new5(struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return new (std::nothrow) QSqlQuery(query_QString);
+}
+
+QSqlQuery* QSqlQuery_new6(struct miqt_string query, QSqlDatabase* db) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return new (std::nothrow) QSqlQuery(query_QString, *db);
+}
+
+void QSqlQuery_operatorAssign(QSqlQuery* self, QSqlQuery* other) {
+	self->operator=(*other);
+}
+
+void QSqlQuery_swap(QSqlQuery* self, QSqlQuery* other) {
+	self->swap(*other);
+}
+
+bool QSqlQuery_isValid(const QSqlQuery* self) {
+	return self->isValid();
+}
+
+bool QSqlQuery_isActive(const QSqlQuery* self) {
+	return self->isActive();
+}
+
+bool QSqlQuery_isNull(const QSqlQuery* self, int field) {
+	return self->isNull(static_cast<int>(field));
+}
+
+bool QSqlQuery_isNullWithName(const QSqlQuery* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->isNull(name_QString);
+}
+
+int QSqlQuery_at(const QSqlQuery* self) {
+	return self->at();
+}
+
+struct miqt_string QSqlQuery_lastQuery(const QSqlQuery* self) {
+	QString _ret = self->lastQuery();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+int QSqlQuery_numRowsAffected(const QSqlQuery* self) {
+	return self->numRowsAffected();
+}
+
+QSqlError* QSqlQuery_lastError(const QSqlQuery* self) {
+	return new QSqlError(self->lastError());
+}
+
+bool QSqlQuery_isSelect(const QSqlQuery* self) {
+	return self->isSelect();
+}
+
+int QSqlQuery_size(const QSqlQuery* self) {
+	return self->size();
+}
+
+QSqlDriver* QSqlQuery_driver(const QSqlQuery* self) {
+	return (QSqlDriver*) self->driver();
+}
+
+QSqlResult* QSqlQuery_result(const QSqlQuery* self) {
+	return (QSqlResult*) self->result();
+}
+
+bool QSqlQuery_isForwardOnly(const QSqlQuery* self) {
+	return self->isForwardOnly();
+}
+
+QSqlRecord* QSqlQuery_record(const QSqlQuery* self) {
+	return new QSqlRecord(self->record());
+}
+
+void QSqlQuery_setForwardOnly(QSqlQuery* self, bool forward) {
+	self->setForwardOnly(forward);
+}
+
+bool QSqlQuery_exec(QSqlQuery* self, struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return self->exec(query_QString);
+}
+
+QVariant* QSqlQuery_value(const QSqlQuery* self, int i) {
+	return new QVariant(self->value(static_cast<int>(i)));
+}
+
+QVariant* QSqlQuery_valueWithName(const QSqlQuery* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new QVariant(self->value(name_QString));
+}
+
+void QSqlQuery_setNumericalPrecisionPolicy(QSqlQuery* self, int precisionPolicy) {
+	self->setNumericalPrecisionPolicy(static_cast<QSql::NumericalPrecisionPolicy>(precisionPolicy));
+}
+
+int QSqlQuery_numericalPrecisionPolicy(const QSqlQuery* self) {
+	QSql::NumericalPrecisionPolicy _ret = self->numericalPrecisionPolicy();
+	return static_cast<int>(_ret);
+}
+
+bool QSqlQuery_seek(QSqlQuery* self, int i) {
+	return self->seek(static_cast<int>(i));
+}
+
+bool QSqlQuery_next(QSqlQuery* self) {
+	return self->next();
+}
+
+bool QSqlQuery_previous(QSqlQuery* self) {
+	return self->previous();
+}
+
+bool QSqlQuery_first(QSqlQuery* self) {
+	return self->first();
+}
+
+bool QSqlQuery_last(QSqlQuery* self) {
+	return self->last();
+}
+
+void QSqlQuery_clear(QSqlQuery* self) {
+	self->clear();
+}
+
+bool QSqlQuery_exec2(QSqlQuery* self) {
+	return self->exec();
+}
+
+bool QSqlQuery_execBatch(QSqlQuery* self) {
+	return self->execBatch();
+}
+
+bool QSqlQuery_prepare(QSqlQuery* self, struct miqt_string query) {
+	QString query_QString = QString::fromUtf8(query.data, query.len);
+	return self->prepare(query_QString);
+}
+
+void QSqlQuery_bindValue(QSqlQuery* self, struct miqt_string placeholder, QVariant* val) {
+	QString placeholder_QString = QString::fromUtf8(placeholder.data, placeholder.len);
+	self->bindValue(placeholder_QString, *val);
+}
+
+void QSqlQuery_bindValue2(QSqlQuery* self, int pos, QVariant* val) {
+	self->bindValue(static_cast<int>(pos), *val);
+}
+
+void QSqlQuery_addBindValue(QSqlQuery* self, QVariant* val) {
+	self->addBindValue(*val);
+}
+
+QVariant* QSqlQuery_boundValue(const QSqlQuery* self, struct miqt_string placeholder) {
+	QString placeholder_QString = QString::fromUtf8(placeholder.data, placeholder.len);
+	return new QVariant(self->boundValue(placeholder_QString));
+}
+
+QVariant* QSqlQuery_boundValueWithPos(const QSqlQuery* self, int pos) {
+	return new QVariant(self->boundValue(static_cast<int>(pos)));
+}
+
+struct miqt_array /* of QVariant* */  QSqlQuery_boundValues(const QSqlQuery* self) {
+	QVariantList _ret = self->boundValues();
+	// Convert QList<> from C++ memory to manually-managed C memory
+	QVariant** _arr = static_cast<QVariant**>(malloc(sizeof(QVariant*) * _ret.length()));
+	for (size_t i = 0, e = _ret.length(); i < e; ++i) {
+		_arr[i] = new QVariant(_ret[i]);
+	}
+	struct miqt_array _out;
+	_out.len = _ret.length();
+	_out.data = static_cast<void*>(_arr);
+	return _out;
+}
+
+struct miqt_string QSqlQuery_executedQuery(const QSqlQuery* self) {
+	QString _ret = self->executedQuery();
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QVariant* QSqlQuery_lastInsertId(const QSqlQuery* self) {
+	return new QVariant(self->lastInsertId());
+}
+
+void QSqlQuery_finish(QSqlQuery* self) {
+	self->finish();
+}
+
+bool QSqlQuery_nextResult(QSqlQuery* self) {
+	return self->nextResult();
+}
+
+bool QSqlQuery_seek2(QSqlQuery* self, int i, bool relative) {
+	return self->seek(static_cast<int>(i), relative);
+}
+
+bool QSqlQuery_execBatchWithMode(QSqlQuery* self, int mode) {
+	return self->execBatch(static_cast<QSqlQuery::BatchExecutionMode>(mode));
+}
+
+void QSqlQuery_bindValue3(QSqlQuery* self, struct miqt_string placeholder, QVariant* val, int type) {
+	QString placeholder_QString = QString::fromUtf8(placeholder.data, placeholder.len);
+	self->bindValue(placeholder_QString, *val, static_cast<QSql::ParamType>(type));
+}
+
+void QSqlQuery_bindValue4(QSqlQuery* self, int pos, QVariant* val, int type) {
+	self->bindValue(static_cast<int>(pos), *val, static_cast<QSql::ParamType>(type));
+}
+
+void QSqlQuery_addBindValue2(QSqlQuery* self, QVariant* val, int type) {
+	self->addBindValue(*val, static_cast<QSql::ParamType>(type));
+}
+
+void QSqlQuery_delete(QSqlQuery* self) {
+	delete self;
+}
+

qt6/sql/gen_qsqlquery.go

@@ -0,0 +1,352 @@
+package sql
+
+/*
+
+#include "gen_qsqlquery.h"
+#include <stdlib.h>
+
+*/
+import "C"
+
+import (
+	"github.com/mappu/miqt/qt6"
+	"runtime"
+	"unsafe"
+)
+
+type QSqlQuery__BatchExecutionMode int
+
+const (
+	QSqlQuery__ValuesAsRows    QSqlQuery__BatchExecutionMode = 0
+	QSqlQuery__ValuesAsColumns QSqlQuery__BatchExecutionMode = 1
+)
+
+type QSqlQuery struct {
+	h *C.QSqlQuery
+}
+
+func (this *QSqlQuery) cPointer() *C.QSqlQuery {
+	if this == nil {
+		return nil
+	}
+	return this.h
+}
+
+func (this *QSqlQuery) UnsafePointer() unsafe.Pointer {
+	if this == nil {
+		return nil
+	}
+	return unsafe.Pointer(this.h)
+}
+
+// newQSqlQuery constructs the type using only CGO pointers.
+func newQSqlQuery(h *C.QSqlQuery) *QSqlQuery {
+	if h == nil {
+		return nil
+	}
+
+	return &QSqlQuery{h: h}
+}
+
+// UnsafeNewQSqlQuery constructs the type using only unsafe pointers.
+func UnsafeNewQSqlQuery(h unsafe.Pointer) *QSqlQuery {
+	return newQSqlQuery((*C.QSqlQuery)(h))
+}
+
+// NewQSqlQuery constructs a new QSqlQuery object.
+func NewQSqlQuery(r *QSqlResult) *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new(r.cPointer()))
+}
+
+// NewQSqlQuery2 constructs a new QSqlQuery object.
+func NewQSqlQuery2() *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new2())
+}
+
+// NewQSqlQuery3 constructs a new QSqlQuery object.
+func NewQSqlQuery3(db *QSqlDatabase) *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new3(db.cPointer()))
+}
+
+// NewQSqlQuery4 constructs a new QSqlQuery object.
+func NewQSqlQuery4(other *QSqlQuery) *QSqlQuery {
+
+	return newQSqlQuery(C.QSqlQuery_new4(other.cPointer()))
+}
+
+// NewQSqlQuery5 constructs a new QSqlQuery object.
+func NewQSqlQuery5(query string) *QSqlQuery {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+
+	return newQSqlQuery(C.QSqlQuery_new5(query_ms))
+}
+
+// NewQSqlQuery6 constructs a new QSqlQuery object.
+func NewQSqlQuery6(query string, db *QSqlDatabase) *QSqlQuery {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+
+	return newQSqlQuery(C.QSqlQuery_new6(query_ms, db.cPointer()))
+}
+
+func (this *QSqlQuery) OperatorAssign(other *QSqlQuery) {
+	C.QSqlQuery_operatorAssign(this.h, other.cPointer())
+}
+
+func (this *QSqlQuery) Swap(other *QSqlQuery) {
+	C.QSqlQuery_swap(this.h, other.cPointer())
+}
+
+func (this *QSqlQuery) IsValid() bool {
+	return (bool)(C.QSqlQuery_isValid(this.h))
+}
+
+func (this *QSqlQuery) IsActive() bool {
+	return (bool)(C.QSqlQuery_isActive(this.h))
+}
+
+func (this *QSqlQuery) IsNull(field int) bool {
+	return (bool)(C.QSqlQuery_isNull(this.h, (C.int)(field)))
+}
+
+func (this *QSqlQuery) IsNullWithName(name string) bool {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	return (bool)(C.QSqlQuery_isNullWithName(this.h, name_ms))
+}
+
+func (this *QSqlQuery) At() int {
+	return (int)(C.QSqlQuery_at(this.h))
+}
+
+func (this *QSqlQuery) LastQuery() string {
+	var _ms C.struct_miqt_string = C.QSqlQuery_lastQuery(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlQuery) NumRowsAffected() int {
+	return (int)(C.QSqlQuery_numRowsAffected(this.h))
+}
+
+func (this *QSqlQuery) LastError() *QSqlError {
+	_goptr := newQSqlError(C.QSqlQuery_lastError(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) IsSelect() bool {
+	return (bool)(C.QSqlQuery_isSelect(this.h))
+}
+
+func (this *QSqlQuery) Size() int {
+	return (int)(C.QSqlQuery_size(this.h))
+}
+
+func (this *QSqlQuery) Driver() *QSqlDriver {
+	return newQSqlDriver(C.QSqlQuery_driver(this.h))
+}
+
+func (this *QSqlQuery) Result() *QSqlResult {
+	return newQSqlResult(C.QSqlQuery_result(this.h))
+}
+
+func (this *QSqlQuery) IsForwardOnly() bool {
+	return (bool)(C.QSqlQuery_isForwardOnly(this.h))
+}
+
+func (this *QSqlQuery) Record() *QSqlRecord {
+	_goptr := newQSqlRecord(C.QSqlQuery_record(this.h))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) SetForwardOnly(forward bool) {
+	C.QSqlQuery_setForwardOnly(this.h, (C.bool)(forward))
+}
+
+func (this *QSqlQuery) Exec(query string) bool {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+	return (bool)(C.QSqlQuery_exec(this.h, query_ms))
+}
+
+func (this *QSqlQuery) Value(i int) *qt6.QVariant {
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_value(this.h, (C.int)(i))))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) ValueWithName(name string) *qt6.QVariant {
+	name_ms := C.struct_miqt_string{}
+	name_ms.data = C.CString(name)
+	name_ms.len = C.size_t(len(name))
+	defer C.free(unsafe.Pointer(name_ms.data))
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_valueWithName(this.h, name_ms)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) SetNumericalPrecisionPolicy(precisionPolicy QSql__NumericalPrecisionPolicy) {
+	C.QSqlQuery_setNumericalPrecisionPolicy(this.h, (C.int)(precisionPolicy))
+}
+
+func (this *QSqlQuery) NumericalPrecisionPolicy() QSql__NumericalPrecisionPolicy {
+	return (QSql__NumericalPrecisionPolicy)(C.QSqlQuery_numericalPrecisionPolicy(this.h))
+}
+
+func (this *QSqlQuery) Seek(i int) bool {
+	return (bool)(C.QSqlQuery_seek(this.h, (C.int)(i)))
+}
+
+func (this *QSqlQuery) Next() bool {
+	return (bool)(C.QSqlQuery_next(this.h))
+}
+
+func (this *QSqlQuery) Previous() bool {
+	return (bool)(C.QSqlQuery_previous(this.h))
+}
+
+func (this *QSqlQuery) First() bool {
+	return (bool)(C.QSqlQuery_first(this.h))
+}
+
+func (this *QSqlQuery) Last() bool {
+	return (bool)(C.QSqlQuery_last(this.h))
+}
+
+func (this *QSqlQuery) Clear() {
+	C.QSqlQuery_clear(this.h)
+}
+
+func (this *QSqlQuery) Exec2() bool {
+	return (bool)(C.QSqlQuery_exec2(this.h))
+}
+
+func (this *QSqlQuery) ExecBatch() bool {
+	return (bool)(C.QSqlQuery_execBatch(this.h))
+}
+
+func (this *QSqlQuery) Prepare(query string) bool {
+	query_ms := C.struct_miqt_string{}
+	query_ms.data = C.CString(query)
+	query_ms.len = C.size_t(len(query))
+	defer C.free(unsafe.Pointer(query_ms.data))
+	return (bool)(C.QSqlQuery_prepare(this.h, query_ms))
+}
+
+func (this *QSqlQuery) BindValue(placeholder string, val *qt6.QVariant) {
+	placeholder_ms := C.struct_miqt_string{}
+	placeholder_ms.data = C.CString(placeholder)
+	placeholder_ms.len = C.size_t(len(placeholder))
+	defer C.free(unsafe.Pointer(placeholder_ms.data))
+	C.QSqlQuery_bindValue(this.h, placeholder_ms, (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlQuery) BindValue2(pos int, val *qt6.QVariant) {
+	C.QSqlQuery_bindValue2(this.h, (C.int)(pos), (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlQuery) AddBindValue(val *qt6.QVariant) {
+	C.QSqlQuery_addBindValue(this.h, (*C.QVariant)(val.UnsafePointer()))
+}
+
+func (this *QSqlQuery) BoundValue(placeholder string) *qt6.QVariant {
+	placeholder_ms := C.struct_miqt_string{}
+	placeholder_ms.data = C.CString(placeholder)
+	placeholder_ms.len = C.size_t(len(placeholder))
+	defer C.free(unsafe.Pointer(placeholder_ms.data))
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_boundValue(this.h, placeholder_ms)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) BoundValueWithPos(pos int) *qt6.QVariant {
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_boundValueWithPos(this.h, (C.int)(pos))))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) BoundValues() []qt6.QVariant {
+	var _ma C.struct_miqt_array = C.QSqlQuery_boundValues(this.h)
+	_ret := make([]qt6.QVariant, int(_ma.len))
+	_outCast := (*[0xffff]*C.QVariant)(unsafe.Pointer(_ma.data)) // hey ya
+	for i := 0; i < int(_ma.len); i++ {
+		_lv_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(_outCast[i]))
+		_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+		_ret[i] = *_lv_goptr
+	}
+	return _ret
+}
+
+func (this *QSqlQuery) ExecutedQuery() string {
+	var _ms C.struct_miqt_string = C.QSqlQuery_executedQuery(this.h)
+	_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
+	C.free(unsafe.Pointer(_ms.data))
+	return _ret
+}
+
+func (this *QSqlQuery) LastInsertId() *qt6.QVariant {
+	_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(C.QSqlQuery_lastInsertId(this.h)))
+	_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
+	return _goptr
+}
+
+func (this *QSqlQuery) Finish() {
+	C.QSqlQuery_finish(this.h)
+}
+
+func (this *QSqlQuery) NextResult() bool {
+	return (bool)(C.QSqlQuery_nextResult(this.h))
+}
+
+func (this *QSqlQuery) Seek2(i int, relative bool) bool {
+	return (bool)(C.QSqlQuery_seek2(this.h, (C.int)(i), (C.bool)(relative)))
+}
+
+func (this *QSqlQuery) ExecBatchWithMode(mode QSqlQuery__BatchExecutionMode) bool {
+	return (bool)(C.QSqlQuery_execBatchWithMode(this.h, (C.int)(mode)))
+}
+
+func (this *QSqlQuery) BindValue3(placeholder string, val *qt6.QVariant, typeVal QSql__ParamTypeFlag) {
+	placeholder_ms := C.struct_miqt_string{}
+	placeholder_ms.data = C.CString(placeholder)
+	placeholder_ms.len = C.size_t(len(placeholder))
+	defer C.free(unsafe.Pointer(placeholder_ms.data))
+	C.QSqlQuery_bindValue3(this.h, placeholder_ms, (*C.QVariant)(val.UnsafePointer()), (C.int)(typeVal))
+}
+
+func (this *QSqlQuery) BindValue4(pos int, val *qt6.QVariant, typeVal QSql__ParamTypeFlag) {
+	C.QSqlQuery_bindValue4(this.h, (C.int)(pos), (*C.QVariant)(val.UnsafePointer()), (C.int)(typeVal))
+}
+
+func (this *QSqlQuery) AddBindValue2(val *qt6.QVariant, typeVal QSql__ParamTypeFlag) {
+	C.QSqlQuery_addBindValue2(this.h, (*C.QVariant)(val.UnsafePointer()), (C.int)(typeVal))
+}
+
+// Delete this object from C++ memory.
+func (this *QSqlQuery) Delete() {
+	C.QSqlQuery_delete(this.h)
+}
+
+// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
+// from C++ memory once it is unreachable from Go memory.
+func (this *QSqlQuery) GoGC() {
+	runtime.SetFinalizer(this, func(this *QSqlQuery) {
+		this.Delete()
+		runtime.KeepAlive(this.h)
+	})
+}

qt6/sql/gen_qsqlquery.h

@@ -0,0 +1,94 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLQUERY_H
+#define MIQT_QT6_SQL_GEN_QSQLQUERY_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QSqlDatabase;
+class QSqlDriver;
+class QSqlError;
+class QSqlQuery;
+class QSqlRecord;
+class QSqlResult;
+class QVariant;
+#else
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlDriver QSqlDriver;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QSqlResult QSqlResult;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlQuery* QSqlQuery_new(QSqlResult* r);
+QSqlQuery* QSqlQuery_new2();
+QSqlQuery* QSqlQuery_new3(QSqlDatabase* db);
+QSqlQuery* QSqlQuery_new4(QSqlQuery* other);
+QSqlQuery* QSqlQuery_new5(struct miqt_string query);
+QSqlQuery* QSqlQuery_new6(struct miqt_string query, QSqlDatabase* db);
+void QSqlQuery_operatorAssign(QSqlQuery* self, QSqlQuery* other);
+void QSqlQuery_swap(QSqlQuery* self, QSqlQuery* other);
+bool QSqlQuery_isValid(const QSqlQuery* self);
+bool QSqlQuery_isActive(const QSqlQuery* self);
+bool QSqlQuery_isNull(const QSqlQuery* self, int field);
+bool QSqlQuery_isNullWithName(const QSqlQuery* self, struct miqt_string name);
+int QSqlQuery_at(const QSqlQuery* self);
+struct miqt_string QSqlQuery_lastQuery(const QSqlQuery* self);
+int QSqlQuery_numRowsAffected(const QSqlQuery* self);
+QSqlError* QSqlQuery_lastError(const QSqlQuery* self);
+bool QSqlQuery_isSelect(const QSqlQuery* self);
+int QSqlQuery_size(const QSqlQuery* self);
+QSqlDriver* QSqlQuery_driver(const QSqlQuery* self);
+QSqlResult* QSqlQuery_result(const QSqlQuery* self);
+bool QSqlQuery_isForwardOnly(const QSqlQuery* self);
+QSqlRecord* QSqlQuery_record(const QSqlQuery* self);
+void QSqlQuery_setForwardOnly(QSqlQuery* self, bool forward);
+bool QSqlQuery_exec(QSqlQuery* self, struct miqt_string query);
+QVariant* QSqlQuery_value(const QSqlQuery* self, int i);
+QVariant* QSqlQuery_valueWithName(const QSqlQuery* self, struct miqt_string name);
+void QSqlQuery_setNumericalPrecisionPolicy(QSqlQuery* self, int precisionPolicy);
+int QSqlQuery_numericalPrecisionPolicy(const QSqlQuery* self);
+bool QSqlQuery_seek(QSqlQuery* self, int i);
+bool QSqlQuery_next(QSqlQuery* self);
+bool QSqlQuery_previous(QSqlQuery* self);
+bool QSqlQuery_first(QSqlQuery* self);
+bool QSqlQuery_last(QSqlQuery* self);
+void QSqlQuery_clear(QSqlQuery* self);
+bool QSqlQuery_exec2(QSqlQuery* self);
+bool QSqlQuery_execBatch(QSqlQuery* self);
+bool QSqlQuery_prepare(QSqlQuery* self, struct miqt_string query);
+void QSqlQuery_bindValue(QSqlQuery* self, struct miqt_string placeholder, QVariant* val);
+void QSqlQuery_bindValue2(QSqlQuery* self, int pos, QVariant* val);
+void QSqlQuery_addBindValue(QSqlQuery* self, QVariant* val);
+QVariant* QSqlQuery_boundValue(const QSqlQuery* self, struct miqt_string placeholder);
+QVariant* QSqlQuery_boundValueWithPos(const QSqlQuery* self, int pos);
+struct miqt_array /* of QVariant* */  QSqlQuery_boundValues(const QSqlQuery* self);
+struct miqt_string QSqlQuery_executedQuery(const QSqlQuery* self);
+QVariant* QSqlQuery_lastInsertId(const QSqlQuery* self);
+void QSqlQuery_finish(QSqlQuery* self);
+bool QSqlQuery_nextResult(QSqlQuery* self);
+bool QSqlQuery_seek2(QSqlQuery* self, int i, bool relative);
+bool QSqlQuery_execBatchWithMode(QSqlQuery* self, int mode);
+void QSqlQuery_bindValue3(QSqlQuery* self, struct miqt_string placeholder, QVariant* val, int type);
+void QSqlQuery_bindValue4(QSqlQuery* self, int pos, QVariant* val, int type);
+void QSqlQuery_addBindValue2(QSqlQuery* self, QVariant* val, int type);
+
+void QSqlQuery_delete(QSqlQuery* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqlquerymodel.h

@@ -0,0 +1,211 @@
+#pragma once
+#ifndef MIQT_QT6_SQL_GEN_QSQLQUERYMODEL_H
+#define MIQT_QT6_SQL_GEN_QSQLQUERYMODEL_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include "../../libmiqt/libmiqt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+class QAbstractItemModel;
+class QAbstractTableModel;
+class QChildEvent;
+class QDataStream;
+class QEvent;
+class QMetaMethod;
+class QMetaObject;
+class QMimeData;
+class QModelIndex;
+class QModelRoleDataSpan;
+class QObject;
+class QSize;
+class QSqlDatabase;
+class QSqlError;
+class QSqlQuery;
+class QSqlQueryModel;
+class QSqlRecord;
+class QTimerEvent;
+class QVariant;
+#else
+typedef struct QAbstractItemModel QAbstractItemModel;
+typedef struct QAbstractTableModel QAbstractTableModel;
+typedef struct QChildEvent QChildEvent;
+typedef struct QDataStream QDataStream;
+typedef struct QEvent QEvent;
+typedef struct QMetaMethod QMetaMethod;
+typedef struct QMetaObject QMetaObject;
+typedef struct QMimeData QMimeData;
+typedef struct QModelIndex QModelIndex;
+typedef struct QModelRoleDataSpan QModelRoleDataSpan;
+typedef struct QObject QObject;
+typedef struct QSize QSize;
+typedef struct QSqlDatabase QSqlDatabase;
+typedef struct QSqlError QSqlError;
+typedef struct QSqlQuery QSqlQuery;
+typedef struct QSqlQueryModel QSqlQueryModel;
+typedef struct QSqlRecord QSqlRecord;
+typedef struct QTimerEvent QTimerEvent;
+typedef struct QVariant QVariant;
+#endif
+
+QSqlQueryModel* QSqlQueryModel_new();
+QSqlQueryModel* QSqlQueryModel_new2(QObject* parent);
+void QSqlQueryModel_virtbase(QSqlQueryModel* src, QAbstractTableModel** outptr_QAbstractTableModel);
+QMetaObject* QSqlQueryModel_metaObject(const QSqlQueryModel* self);
+void* QSqlQueryModel_metacast(QSqlQueryModel* self, const char* param1);
+struct miqt_string QSqlQueryModel_tr(const char* s);
+int QSqlQueryModel_rowCount(const QSqlQueryModel* self, QModelIndex* parent);
+int QSqlQueryModel_columnCount(const QSqlQueryModel* self, QModelIndex* parent);
+QSqlRecord* QSqlQueryModel_record(const QSqlQueryModel* self, int row);
+QSqlRecord* QSqlQueryModel_record2(const QSqlQueryModel* self);
+QVariant* QSqlQueryModel_data(const QSqlQueryModel* self, QModelIndex* item, int role);
+QVariant* QSqlQueryModel_headerData(const QSqlQueryModel* self, int section, int orientation, int role);
+bool QSqlQueryModel_setHeaderData(QSqlQueryModel* self, int section, int orientation, QVariant* value, int role);
+bool QSqlQueryModel_insertColumns(QSqlQueryModel* self, int column, int count, QModelIndex* parent);
+bool QSqlQueryModel_removeColumns(QSqlQueryModel* self, int column, int count, QModelIndex* parent);
+void QSqlQueryModel_setQuery(QSqlQueryModel* self, QSqlQuery* query);
+void QSqlQueryModel_setQueryWithQuery(QSqlQueryModel* self, struct miqt_string query);
+QSqlQuery* QSqlQueryModel_query(const QSqlQueryModel* self);
+void QSqlQueryModel_clear(QSqlQueryModel* self);
+QSqlError* QSqlQueryModel_lastError(const QSqlQueryModel* self);
+void QSqlQueryModel_fetchMore(QSqlQueryModel* self, QModelIndex* parent);
+bool QSqlQueryModel_canFetchMore(const QSqlQueryModel* self, QModelIndex* parent);
+struct miqt_map /* of int to struct miqt_string */  QSqlQueryModel_roleNames(const QSqlQueryModel* self);
+void QSqlQueryModel_queryChange(QSqlQueryModel* self);
+QModelIndex* QSqlQueryModel_indexInQuery(const QSqlQueryModel* self, QModelIndex* item);
+struct miqt_string QSqlQueryModel_tr2(const char* s, const char* c);
+struct miqt_string QSqlQueryModel_tr3(const char* s, const char* c, int n);
+void QSqlQueryModel_setQuery2(QSqlQueryModel* self, struct miqt_string query, QSqlDatabase* db);
+
+bool QSqlQueryModel_override_virtual_rowCount(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_rowCount(const void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_columnCount(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_columnCount(const void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_data(void* self, intptr_t slot);
+QVariant* QSqlQueryModel_virtualbase_data(const void* self, QModelIndex* item, int role);
+bool QSqlQueryModel_override_virtual_headerData(void* self, intptr_t slot);
+QVariant* QSqlQueryModel_virtualbase_headerData(const void* self, int section, int orientation, int role);
+bool QSqlQueryModel_override_virtual_setHeaderData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_setHeaderData(void* self, int section, int orientation, QVariant* value, int role);
+bool QSqlQueryModel_override_virtual_insertColumns(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_insertColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_removeColumns(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_removeColumns(void* self, int column, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_clear(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_clear(void* self);
+bool QSqlQueryModel_override_virtual_fetchMore(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_fetchMore(void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_canFetchMore(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_canFetchMore(const void* self, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_roleNames(void* self, intptr_t slot);
+struct miqt_map /* of int to struct miqt_string */  QSqlQueryModel_virtualbase_roleNames(const void* self);
+bool QSqlQueryModel_override_virtual_queryChange(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_queryChange(void* self);
+bool QSqlQueryModel_override_virtual_indexInQuery(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_indexInQuery(const void* self, QModelIndex* item);
+bool QSqlQueryModel_override_virtual_index(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_index(const void* self, int row, int column, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_sibling(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_sibling(const void* self, int row, int column, QModelIndex* idx);
+bool QSqlQueryModel_override_virtual_dropMimeData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_dropMimeData(void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_flags(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_flags(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_setData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_setData(void* self, QModelIndex* index, QVariant* value, int role);
+bool QSqlQueryModel_override_virtual_itemData(void* self, intptr_t slot);
+struct miqt_map /* of int to QVariant* */  QSqlQueryModel_virtualbase_itemData(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_setItemData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_setItemData(void* self, QModelIndex* index, struct miqt_map /* of int to QVariant* */  roles);
+bool QSqlQueryModel_override_virtual_clearItemData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_clearItemData(void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_mimeTypes(void* self, intptr_t slot);
+struct miqt_array /* of struct miqt_string */  QSqlQueryModel_virtualbase_mimeTypes(const void* self);
+bool QSqlQueryModel_override_virtual_mimeData(void* self, intptr_t slot);
+QMimeData* QSqlQueryModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */  indexes);
+bool QSqlQueryModel_override_virtual_canDropMimeData(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_canDropMimeData(const void* self, QMimeData* data, int action, int row, int column, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_supportedDropActions(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_supportedDropActions(const void* self);
+bool QSqlQueryModel_override_virtual_supportedDragActions(void* self, intptr_t slot);
+int QSqlQueryModel_virtualbase_supportedDragActions(const void* self);
+bool QSqlQueryModel_override_virtual_insertRows(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_insertRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_removeRows(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_removeRows(void* self, int row, int count, QModelIndex* parent);
+bool QSqlQueryModel_override_virtual_moveRows(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_moveRows(void* self, QModelIndex* sourceParent, int sourceRow, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlQueryModel_override_virtual_moveColumns(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_moveColumns(void* self, QModelIndex* sourceParent, int sourceColumn, int count, QModelIndex* destinationParent, int destinationChild);
+bool QSqlQueryModel_override_virtual_sort(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_sort(void* self, int column, int order);
+bool QSqlQueryModel_override_virtual_buddy(void* self, intptr_t slot);
+QModelIndex* QSqlQueryModel_virtualbase_buddy(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_match(void* self, intptr_t slot);
+struct miqt_array /* of QModelIndex* */  QSqlQueryModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags);
+bool QSqlQueryModel_override_virtual_span(void* self, intptr_t slot);
+QSize* QSqlQueryModel_virtualbase_span(const void* self, QModelIndex* index);
+bool QSqlQueryModel_override_virtual_multiData(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_multiData(const void* self, QModelIndex* index, QModelRoleDataSpan* roleDataSpan);
+bool QSqlQueryModel_override_virtual_submit(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_submit(void* self);
+bool QSqlQueryModel_override_virtual_revert(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_revert(void* self);
+bool QSqlQueryModel_override_virtual_resetInternalData(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_resetInternalData(void* self);
+bool QSqlQueryModel_override_virtual_event(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_event(void* self, QEvent* event);
+bool QSqlQueryModel_override_virtual_eventFilter(void* self, intptr_t slot);
+bool QSqlQueryModel_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
+bool QSqlQueryModel_override_virtual_timerEvent(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_timerEvent(void* self, QTimerEvent* event);
+bool QSqlQueryModel_override_virtual_childEvent(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_childEvent(void* self, QChildEvent* event);
+bool QSqlQueryModel_override_virtual_customEvent(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_customEvent(void* self, QEvent* event);
+bool QSqlQueryModel_override_virtual_connectNotify(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_connectNotify(void* self, QMetaMethod* signal);
+bool QSqlQueryModel_override_virtual_disconnectNotify(void* self, intptr_t slot);
+void QSqlQueryModel_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
+
+void QSqlQueryModel_protectedbase_beginInsertRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endInsertRows(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginRemoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endRemoveRows(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginInsertColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endInsertColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginRemoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* parent, int first, int last);
+void QSqlQueryModel_protectedbase_endRemoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_beginResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_endResetModel(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_setLastError(bool* _dynamic_cast_ok, void* self, QSqlError* error);
+QModelIndex* QSqlQueryModel_protectedbase_createIndex(bool* _dynamic_cast_ok, const void* self, int row, int column);
+void QSqlQueryModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self, struct miqt_array /* of QModelIndex* */  indexes, QDataStream* stream);
+bool QSqlQueryModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream);
+bool QSqlQueryModel_protectedbase_beginMoveRows(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationRow);
+void QSqlQueryModel_protectedbase_endMoveRows(bool* _dynamic_cast_ok, void* self);
+bool QSqlQueryModel_protectedbase_beginMoveColumns(bool* _dynamic_cast_ok, void* self, QModelIndex* sourceParent, int sourceFirst, int sourceLast, QModelIndex* destinationParent, int destinationColumn);
+void QSqlQueryModel_protectedbase_endMoveColumns(bool* _dynamic_cast_ok, void* self);
+void QSqlQueryModel_protectedbase_changePersistentIndex(bool* _dynamic_cast_ok, void* self, QModelIndex* from, QModelIndex* to);
+void QSqlQueryModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, void* self, struct miqt_array /* of QModelIndex* */  from, struct miqt_array /* of QModelIndex* */  to);
+struct miqt_array /* of QModelIndex* */  QSqlQueryModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self);
+QObject* QSqlQueryModel_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
+int QSqlQueryModel_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
+int QSqlQueryModel_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
+bool QSqlQueryModel_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
+
+void QSqlQueryModel_delete(QSqlQueryModel* self);
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+#endif

qt6/sql/gen_qsqlrecord.cpp

@@ -0,0 +1,161 @@
+#include <QSqlField>
+#include <QSqlRecord>
+#include <QString>
+#include <QByteArray>
+#include <cstring>
+#include <QVariant>
+#include <qsqlrecord.h>
+#include "gen_qsqlrecord.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+} /* extern C */
+#endif
+
+QSqlRecord* QSqlRecord_new() {
+	return new (std::nothrow) QSqlRecord();
+}
+
+QSqlRecord* QSqlRecord_new2(QSqlRecord* other) {
+	return new (std::nothrow) QSqlRecord(*other);
+}
+
+void QSqlRecord_operatorAssign(QSqlRecord* self, QSqlRecord* other) {
+	self->operator=(*other);
+}
+
+bool QSqlRecord_operatorEqual(const QSqlRecord* self, QSqlRecord* other) {
+	return (*self == *other);
+}
+
+bool QSqlRecord_operatorNotEqual(const QSqlRecord* self, QSqlRecord* other) {
+	return (*self != *other);
+}
+
+QVariant* QSqlRecord_value(const QSqlRecord* self, int i) {
+	return new QVariant(self->value(static_cast<int>(i)));
+}
+
+QVariant* QSqlRecord_valueWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new QVariant(self->value(name_QString));
+}
+
+void QSqlRecord_setValue(QSqlRecord* self, int i, QVariant* val) {
+	self->setValue(static_cast<int>(i), *val);
+}
+
+void QSqlRecord_setValue2(QSqlRecord* self, struct miqt_string name, QVariant* val) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setValue(name_QString, *val);
+}
+
+void QSqlRecord_setNull(QSqlRecord* self, int i) {
+	self->setNull(static_cast<int>(i));
+}
+
+void QSqlRecord_setNullWithName(QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setNull(name_QString);
+}
+
+bool QSqlRecord_isNull(const QSqlRecord* self, int i) {
+	return self->isNull(static_cast<int>(i));
+}
+
+bool QSqlRecord_isNullWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->isNull(name_QString);
+}
+
+int QSqlRecord_indexOf(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->indexOf(name_QString);
+}
+
+struct miqt_string QSqlRecord_fieldName(const QSqlRecord* self, int i) {
+	QString _ret = self->fieldName(static_cast<int>(i));
+	// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
+	QByteArray _b = _ret.toUtf8();
+	struct miqt_string _ms;
+	_ms.len = _b.length();
+	_ms.data = static_cast<char*>(malloc(_ms.len));
+	memcpy(_ms.data, _b.data(), _ms.len);
+	return _ms;
+}
+
+QSqlField* QSqlRecord_field(const QSqlRecord* self, int i) {
+	return new QSqlField(self->field(static_cast<int>(i)));
+}
+
+QSqlField* QSqlRecord_fieldWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return new QSqlField(self->field(name_QString));
+}
+
+bool QSqlRecord_isGenerated(const QSqlRecord* self, int i) {
+	return self->isGenerated(static_cast<int>(i));
+}
+
+bool QSqlRecord_isGeneratedWithName(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->isGenerated(name_QString);
+}
+
+void QSqlRecord_setGenerated(QSqlRecord* self, struct miqt_string name, bool generated) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	self->setGenerated(name_QString, generated);
+}
+
+void QSqlRecord_setGenerated2(QSqlRecord* self, int i, bool generated) {
+	self->setGenerated(static_cast<int>(i), generated);
+}
+
+void QSqlRecord_append(QSqlRecord* self, QSqlField* field) {
+	self->append(*field);
+}
+
+void QSqlRecord_replace(QSqlRecord* self, int pos, QSqlField* field) {
+	self->replace(static_cast<int>(pos), *field);
+}
+
+void QSqlRecord_insert(QSqlRecord* self, int pos, QSqlField* field) {
+	self->insert(static_cast<int>(pos), *field);
+}
+
+void QSqlRecord_remove(QSqlRecord* self, int pos) {
+	self->remove(static_cast<int>(pos));
+}
+
+bool QSqlRecord_isEmpty(const QSqlRecord* self) {
+	return self->isEmpty();
+}
+
+bool QSqlRecord_contains(const QSqlRecord* self, struct miqt_string name) {
+	QString name_QString = QString::fromUtf8(name.data, name.len);
+	return self->contains(name_QString);
+}
+
+void QSqlRecord_clear(QSqlRecord* self) {
+	self->clear();
+}
+
+void QSqlRecord_clearValues(QSqlRecord* self) {
+	self->clearValues();
+}
+
+int QSqlRecord_count(const QSqlRecord* self) {
+	return self->count();
+}
+
+QSqlRecord* QSqlRecord_keyValues(const QSqlRecord* self, QSqlRecord* keyFields) {
+	return new QSqlRecord(self->keyValues(*keyFields));
+}
+
+void QSqlRecord_delete(QSqlRecord* self) {
+	delete self;
+}
+