clickhouse: expose core analysis via sqlc analyze, drop codegen

Wire the ClickHouse engine into `sqlc analyze` so the core catalog and
analyzer can be exercised end to end without committing to code
generation yet. The analyze command builds the compiler, applies the
schema DDL to the core catalog, and reports inferred result columns as
JSON — the same static-analysis path `generate` would use.

Remove the not-yet-ready code generation surface: the ClickHouse Go
type map, the core-catalog to plugin.Catalog projection, and the
generate golden test. ClickHouse type inference is now covered by an
analyze_basic end-to-end case, matching how the other engines are
tested.

Author: kyleconroy

docs/howto/analyze.md

@@ -18,8 +18,8 @@ provided. The schema is always read from the `--schema` file.
 
 ## Flags
 
-- `--dialect`, `-d` - The SQL dialect to use. One of `postgresql`, `mysql`, or
-  `sqlite`. Required.
+- `--dialect`, `-d` - The SQL dialect to use. One of `postgresql`, `mysql`,
+  `sqlite`, or `clickhouse`. Required.
 - `--schema`, `-s` - Path to the schema (DDL) file. Required.
 - `--ast` - Include each statement's AST in the output. Defaults to `false`.
 

internal/cmd/analyze.go

@@ -37,6 +37,9 @@ Examples:
   # Analyze a SQLite query
   sqlc analyze --dialect sqlite --schema schema.sql query.sql
 
+  # Analyze a ClickHouse query
+  sqlc analyze --dialect clickhouse --schema schema.sql query.sql
+
   # Analyze a query piped via stdin
   echo "-- name: GetAuthor :one
   SELECT * FROM authors WHERE id = $1;" | sqlc analyze --dialect postgresql --schema schema.sql
@@ -50,7 +53,7 @@ Examples:
 				return err
 			}
 			if dialect == "" {
-				return fmt.Errorf("--dialect flag is required (postgresql, mysql, or sqlite)")
+				return fmt.Errorf("--dialect flag is required (postgresql, mysql, sqlite, or clickhouse)")
 			}
 
 			schemaPath, err := cmd.Flags().GetString("schema")
@@ -107,8 +110,10 @@ Examples:
 				engine = config.EngineMySQL
 			case "sqlite":
 				engine = config.EngineSQLite
+			case "clickhouse":
+				engine = config.EngineClickHouse
 			default:
-				return fmt.Errorf("unsupported dialect: %s (use postgresql, mysql, or sqlite)", dialect)
+				return fmt.Errorf("unsupported dialect: %s (use postgresql, mysql, sqlite, or clickhouse)", dialect)
 			}
 
 			sql := config.SQL{
@@ -150,7 +155,7 @@ Examples:
 			return nil
 		},
 	}
-	cmd.Flags().StringP("dialect", "d", "", "SQL dialect to use (postgresql, mysql, or sqlite)")
+	cmd.Flags().StringP("dialect", "d", "", "SQL dialect to use (postgresql, mysql, sqlite, or clickhouse)")
 	cmd.Flags().StringP("schema", "s", "", "path to the schema file")
 	cmd.Flags().BoolP("ast", "", false, "include the statement AST in the output")
 	return cmd

internal/cmd/shim.go

@@ -4,7 +4,6 @@ import (
 	"github.com/sqlc-dev/sqlc/internal/compiler"
 	"github.com/sqlc-dev/sqlc/internal/config"
 	"github.com/sqlc-dev/sqlc/internal/config/convert"
-	coreshim "github.com/sqlc-dev/sqlc/internal/core/shim"
 	"github.com/sqlc-dev/sqlc/internal/info"
 	"github.com/sqlc-dev/sqlc/internal/plugin"
 	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
@@ -225,15 +224,9 @@ func pluginQueryParam(p compiler.Parameter) *plugin.Parameter {
 }
 
 func codeGenRequest(r *compiler.Result, settings config.CombinedSettings) *plugin.GenerateRequest {
-	var cat *plugin.Catalog
-	if r.CoreCatalog != nil {
-		cat = coreshim.PluginCatalog(r.CoreCatalog)
-	} else {
-		cat = pluginCatalog(r.Catalog)
-	}
 	return &plugin.GenerateRequest{
 		Settings:    pluginSettings(r, settings),
-		Catalog:     cat,
+		Catalog:     pluginCatalog(r.Catalog),
 		Queries:     pluginQueries(r),
 		SqlcVersion: info.Version,
 	}

internal/codegen/golang/clickhouse_type.go

@@ -86,8 +86,6 @@ func goInnerType(req *plugin.GenerateRequest, options *opts.Options, col *plugin
 		return postgresType(req, options, col)
 	case "sqlite":
 		return sqliteType(req, options, col)
-	case "clickhouse":
-		return clickhouseType(req, options, col)
 	default:
 		return "interface{}"
 	}

internal/codegen/golang/go_type.go

@@ -146,8 +146,7 @@ func (c *Compiler) parseQueries(o opts.Parser) (*Result, error) {
 	}
 
 	return &Result{
-		Catalog:     c.catalog,
-		CoreCatalog: c.coreCatalog,
-		Queries:     q,
+		Catalog: c.catalog,
+		Queries: q,
 	}, nil
 }

internal/compiler/compile.go

@@ -1,13 +1,10 @@
 package compiler
 
 import (
-	"github.com/sqlc-dev/sqlc/internal/core"
 	"github.com/sqlc-dev/sqlc/internal/sql/catalog"
 )
 
 type Result struct {
 	Catalog *catalog.Catalog
 	Queries []*Query
-
-	CoreCatalog *core.Catalog
 }

internal/compiler/result.go

@@ -0,0 +1,5 @@
+{
+  "command": "analyze",
+  "args": ["--dialect", "clickhouse", "--schema", "schema.sql", "query.sql"],
+  "contexts": ["base"]
+}