feat(mysql): allow generating models from information_schema tables

Author: sgtsquiggs

internal/codegen/golang/opts/options.go

@@ -49,6 +49,7 @@ type Options struct {
 	QueryParameterLimit          *int32            `json:"query_parameter_limit,omitempty" yaml:"query_parameter_limit"`
 	OmitSqlcVersion              bool              `json:"omit_sqlc_version,omitempty" yaml:"omit_sqlc_version"`
 	OmitUnusedStructs            bool              `json:"omit_unused_structs,omitempty" yaml:"omit_unused_structs"`
+	OmitCatalogSchema            *bool             `json:"omit_catalog_schema,omitempty" yaml:"omit_catalog_schema"`
 	BuildTags                    string            `json:"build_tags,omitempty" yaml:"build_tags"`
 	Initialisms                  *[]string         `json:"initialisms,omitempty" yaml:"initialisms"`
 
@@ -137,6 +138,11 @@ func parseOpts(req *plugin.GenerateRequest) (*Options, error) {
 		*options.Initialisms = []string{"id"}
 	}
 
+	if options.OmitCatalogSchema == nil {
+		options.OmitCatalogSchema = new(bool)
+		*options.OmitCatalogSchema = true
+	}
+
 	options.InitialismsMap = map[string]struct{}{}
 	for _, initial := range *options.Initialisms {
 		options.InitialismsMap[initial] = struct{}{}

internal/codegen/golang/result.go

@@ -16,7 +16,7 @@ import (
 func buildEnums(req *plugin.GenerateRequest, options *opts.Options) []Enum {
 	var enums []Enum
 	for _, schema := range req.Catalog.Schemas {
-		if schema.Name == "pg_catalog" || schema.Name == "information_schema" {
+		if options.OmitCatalogSchema != nil && *options.OmitCatalogSchema && (schema.Name == "pg_catalog" || schema.Name == "information_schema") {
 			continue
 		}
 		for _, enum := range schema.Enums {
@@ -63,7 +63,7 @@ func buildEnums(req *plugin.GenerateRequest, options *opts.Options) []Enum {
 func buildStructs(req *plugin.GenerateRequest, options *opts.Options) []Struct {
 	var structs []Struct
 	for _, schema := range req.Catalog.Schemas {
-		if schema.Name == "pg_catalog" || schema.Name == "information_schema" {
+		if options.OmitCatalogSchema != nil && *options.OmitCatalogSchema && (schema.Name == "pg_catalog" || schema.Name == "information_schema") {
 			continue
 		}
 		for _, table := range schema.Tables {

internal/codegen/golang/result_test.go

@@ -3,10 +3,66 @@ package golang
 import (
 	"testing"
 
+	"github.com/sqlc-dev/sqlc/internal/codegen/golang/opts"
 	"github.com/sqlc-dev/sqlc/internal/metadata"
 	"github.com/sqlc-dev/sqlc/internal/plugin"
 )
 
+func boolPtr(b bool) *bool { return &b }
+
+func catalogSchemaRequest() *plugin.GenerateRequest {
+	col := func(name, typ string) *plugin.Column {
+		return &plugin.Column{Name: name, Type: &plugin.Identifier{Name: typ}}
+	}
+	table := func(schema, name string, cols ...*plugin.Column) *plugin.Schema {
+		return &plugin.Schema{
+			Name: schema,
+			Tables: []*plugin.Table{
+				{Rel: &plugin.Identifier{Schema: schema, Name: name}, Columns: cols},
+			},
+		}
+	}
+	return &plugin.GenerateRequest{
+		Settings: &plugin.Settings{Engine: "postgresql"},
+		Catalog: &plugin.Catalog{
+			DefaultSchema: "public",
+			Schemas: []*plugin.Schema{
+				table("pg_catalog", "pg_class", col("oid", "oid")),
+				table("information_schema", "tables", col("table_name", "text")),
+				table("public", "users", col("id", "int4")),
+			},
+		},
+	}
+}
+
+func TestBuildStructs_OmitCatalogSchema(t *testing.T) {
+	req := catalogSchemaRequest()
+
+	t.Run("omit=true skips pg_catalog and information_schema", func(t *testing.T) {
+		structs := buildStructs(req, &opts.Options{OmitCatalogSchema: boolPtr(true)})
+		for _, s := range structs {
+			if s.Table != nil && (s.Table.Schema == "pg_catalog" || s.Table.Schema == "information_schema") {
+				t.Errorf("unexpected catalog struct: %s.%s", s.Table.Schema, s.Table.Name)
+			}
+		}
+	})
+
+	t.Run("omit=false includes pg_catalog and information_schema", func(t *testing.T) {
+		structs := buildStructs(req, &opts.Options{OmitCatalogSchema: boolPtr(false)})
+		schemas := make(map[string]bool)
+		for _, s := range structs {
+			if s.Table != nil {
+				schemas[s.Table.Schema] = true
+			}
+		}
+		for _, want := range []string{"pg_catalog", "information_schema", "public"} {
+			if !schemas[want] {
+				t.Errorf("expected structs for schema %q, got none", want)
+			}
+		}
+	})
+}
+
 func TestPutOutColumns_ForZeroColumns(t *testing.T) {
 	tests := []struct {
 		cmd  string