analyzer.go 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590
  1. package analyzer
  2. import (
  3. "fmt"
  4. "strings"
  5. "github.com/danfragoso/pizzasql-next/pkg/lexer"
  6. "github.com/danfragoso/pizzasql-next/pkg/parser"
  7. )
  8. // ErrorType categorizes analysis errors.
  9. type ErrorType int
  10. const (
  11. ErrUnknown ErrorType = iota
  12. ErrTableNotFound
  13. ErrTableExists
  14. ErrColumnNotFound
  15. ErrColumnAmbiguous
  16. ErrTypeMismatch
  17. ErrInvalidFunction
  18. ErrInvalidArgCount
  19. ErrAggregateInWhere
  20. ErrNonAggregateInSelect
  21. ErrInvalidGroupBy
  22. )
  23. // AnalysisError represents a semantic analysis error.
  24. type AnalysisError struct {
  25. Type ErrorType
  26. Message string
  27. Line int
  28. Column int
  29. Context string
  30. }
  31. func (e *AnalysisError) Error() string {
  32. if e.Line > 0 {
  33. return fmt.Sprintf("analysis error at line %d, column %d: %s", e.Line, e.Column, e.Message)
  34. }
  35. return fmt.Sprintf("analysis error: %s", e.Message)
  36. }
  37. // Analyzer performs semantic analysis on parsed SQL statements.
  38. type Analyzer struct {
  39. catalog *Catalog
  40. scope *Scope
  41. errors []*AnalysisError
  42. }
  43. // New creates a new Analyzer with the given catalog.
  44. func New(catalog *Catalog) *Analyzer {
  45. if catalog == nil {
  46. catalog = NewCatalog()
  47. }
  48. return &Analyzer{
  49. catalog: catalog,
  50. }
  51. }
  52. // Analyze performs semantic analysis on a statement.
  53. func (a *Analyzer) Analyze(stmt parser.Statement) error {
  54. a.errors = nil
  55. a.scope = NewScope(nil)
  56. switch s := stmt.(type) {
  57. case *parser.SelectStmt:
  58. return a.analyzeSelect(s)
  59. case *parser.InsertStmt:
  60. return a.analyzeInsert(s)
  61. case *parser.UpdateStmt:
  62. return a.analyzeUpdate(s)
  63. case *parser.DeleteStmt:
  64. return a.analyzeDelete(s)
  65. case *parser.CreateTableStmt:
  66. return a.analyzeCreateTable(s)
  67. case *parser.DropTableStmt:
  68. return a.analyzeDropTable(s)
  69. case *parser.AlterTableStmt:
  70. // ALTER TABLE is handled directly by executor, no semantic analysis needed
  71. return nil
  72. case *parser.AttachStmt:
  73. // ATTACH DATABASE is handled directly by executor
  74. return nil
  75. case *parser.DetachStmt:
  76. // DETACH DATABASE is handled directly by executor
  77. return nil
  78. case *parser.BeginStmt, *parser.CommitStmt, *parser.RollbackStmt,
  79. *parser.SavepointStmt, *parser.ReleaseStmt:
  80. // Transaction statements don't need semantic analysis
  81. return nil
  82. case *parser.AnalyzeStmt:
  83. // ANALYZE is a documented no-op; nothing to validate.
  84. return nil
  85. case *parser.CreateIndexStmt, *parser.DropIndexStmt:
  86. // Index statements don't need semantic analysis
  87. return nil
  88. case *parser.ListenStmt, *parser.UnlistenStmt, *parser.NotifyStmt:
  89. // Channel names and payloads are validated by the parser; there is no
  90. // schema or expression to analyze.
  91. return nil
  92. default:
  93. return &AnalysisError{
  94. Type: ErrUnknown,
  95. Message: fmt.Sprintf("unknown statement type: %T", stmt),
  96. }
  97. }
  98. }
  99. // GetCatalog returns the analyzer's catalog.
  100. func (a *Analyzer) GetCatalog() *Catalog {
  101. return a.catalog
  102. }
  103. // analyzeSelect analyzes a SELECT statement.
  104. func (a *Analyzer) analyzeSelect(stmt *parser.SelectStmt) error {
  105. // Register CTE names before resolving FROM so both the main query and the
  106. // recursive legs can reference them.
  107. for _, cte := range stmt.With {
  108. a.scope.DefineTable(cteTableInfo(cte))
  109. }
  110. // First, resolve tables in FROM clause
  111. if err := a.resolveFromClause(stmt.From); err != nil {
  112. return err
  113. }
  114. // Analyze WHERE clause
  115. if stmt.Where != nil {
  116. info, err := a.analyzeExpr(stmt.Where)
  117. if err != nil {
  118. return err
  119. }
  120. // WHERE clause cannot contain aggregates
  121. if info.IsAggregate {
  122. return &AnalysisError{
  123. Type: ErrAggregateInWhere,
  124. Message: "aggregate functions not allowed in WHERE clause",
  125. }
  126. }
  127. }
  128. // Determine if this is an aggregate query
  129. hasAggregate := false
  130. hasGroupBy := len(stmt.GroupBy) > 0
  131. // Analyze SELECT columns and collect aliases for GROUP BY/ORDER BY/HAVING
  132. // reference. SELECT aliases are registered before GROUP BY so a query may
  133. // group by an output alias, matching SQLite.
  134. selectAliases := make(map[string]*ExprInfo)
  135. for _, col := range stmt.Columns {
  136. if col.Star {
  137. // SELECT * - all columns from all tables
  138. continue
  139. }
  140. if col.TableStar != "" {
  141. // Qualified wildcard (table.*) - validate the qualifier names a
  142. // table or alias in scope; expansion happens at execution time.
  143. if err := a.validateTableStar(col.TableStar); err != nil {
  144. return err
  145. }
  146. continue
  147. }
  148. info, err := a.analyzeExpr(col.Expr)
  149. if err != nil {
  150. return err
  151. }
  152. if info.IsAggregate {
  153. hasAggregate = true
  154. }
  155. // Track column aliases so ORDER BY and HAVING can reference them
  156. if col.Alias != "" {
  157. selectAliases[strings.ToUpper(col.Alias)] = info
  158. }
  159. }
  160. // Register SELECT aliases as virtual columns for GROUP BY/ORDER BY/HAVING
  161. // reference
  162. for alias, info := range selectAliases {
  163. a.scope.DefineSelectAlias(alias, info.Type)
  164. }
  165. // Analyze GROUP BY expressions after aliases are in scope
  166. for _, expr := range stmt.GroupBy {
  167. if _, err := a.analyzeExpr(expr); err != nil {
  168. return err
  169. }
  170. }
  171. // Validate GROUP BY semantics
  172. if hasAggregate && !hasGroupBy {
  173. // Aggregate query without GROUP BY - all non-aggregate columns must be constants
  174. for _, col := range stmt.Columns {
  175. if col.Star {
  176. return &AnalysisError{
  177. Type: ErrNonAggregateInSelect,
  178. Message: "SELECT * not allowed with aggregate functions without GROUP BY",
  179. }
  180. }
  181. if col.TableStar != "" {
  182. return &AnalysisError{
  183. Type: ErrNonAggregateInSelect,
  184. Message: fmt.Sprintf("SELECT %s.* not allowed with aggregate functions without GROUP BY", col.TableStar),
  185. }
  186. }
  187. info, exprErr := a.analyzeExpr(col.Expr)
  188. if exprErr != nil || info == nil {
  189. continue
  190. }
  191. if !info.IsAggregate && !info.IsConstant {
  192. // Check if it's a simple column reference
  193. if ref, ok := col.Expr.(*parser.ColumnRef); ok {
  194. return &AnalysisError{
  195. Type: ErrNonAggregateInSelect,
  196. Message: fmt.Sprintf("column %q must appear in GROUP BY clause or be in an aggregate function", ref.Column),
  197. }
  198. }
  199. }
  200. }
  201. }
  202. // Analyze HAVING clause
  203. if stmt.Having != nil {
  204. info, err := a.analyzeExpr(stmt.Having)
  205. if err != nil {
  206. return err
  207. }
  208. // HAVING without GROUP BY requires aggregates
  209. if !hasGroupBy && !info.IsAggregate {
  210. return &AnalysisError{
  211. Type: ErrInvalidGroupBy,
  212. Message: "HAVING clause requires GROUP BY or aggregate function",
  213. }
  214. }
  215. }
  216. // Analyze ORDER BY
  217. for _, item := range stmt.OrderBy {
  218. if _, err := a.analyzeExpr(item.Expr); err != nil {
  219. return err
  220. }
  221. }
  222. // Analyze LIMIT/OFFSET
  223. if stmt.Limit != nil {
  224. info, err := a.analyzeExpr(stmt.Limit)
  225. if err != nil {
  226. return err
  227. }
  228. if !info.Type.IsNumeric() && info.Type != TypeNull {
  229. return &AnalysisError{
  230. Type: ErrTypeMismatch,
  231. Message: "LIMIT must be numeric",
  232. }
  233. }
  234. }
  235. if stmt.Offset != nil {
  236. info, err := a.analyzeExpr(stmt.Offset)
  237. if err != nil {
  238. return err
  239. }
  240. if !info.Type.IsNumeric() && info.Type != TypeNull {
  241. return &AnalysisError{
  242. Type: ErrTypeMismatch,
  243. Message: "OFFSET must be numeric",
  244. }
  245. }
  246. }
  247. return nil
  248. }
  249. // resolveFromClause adds tables from FROM clause to scope.
  250. func (a *Analyzer) resolveFromClause(tables []parser.TableRef) error {
  251. for _, ref := range tables {
  252. if err := a.defineTableRef(ref); err != nil {
  253. return err
  254. }
  255. // Handle JOINs
  256. if ref.Join != nil {
  257. if err := a.resolveJoin(ref.Join); err != nil {
  258. return err
  259. }
  260. }
  261. }
  262. return nil
  263. }
  264. // defineTableRef adds a single FROM/JOIN table to scope. The reference may be a
  265. // derived table (subquery), a CTE, or a real catalog table.
  266. func (a *Analyzer) defineTableRef(ref parser.TableRef) error {
  267. if ref.Function != nil {
  268. for _, arg := range ref.Function.Args {
  269. if _, err := a.analyzeExpr(arg); err != nil {
  270. return err
  271. }
  272. }
  273. columns := tableFunctionColumns(ref.Function.Name)
  274. names := make([]string, len(columns))
  275. for i, column := range columns {
  276. names[i] = column.Name
  277. }
  278. renamed, err := ref.ApplyColumnAliases(names)
  279. if err != nil {
  280. return err
  281. }
  282. for i := range columns {
  283. columns[i].Name = renamed[i]
  284. }
  285. a.scope.DefineTable(&TableInfo{
  286. Name: ref.Name,
  287. Alias: ref.Alias,
  288. Columns: columns,
  289. })
  290. return nil
  291. }
  292. if ref.Subquery != nil {
  293. if err := a.analyzeSelect(ref.Subquery); err != nil {
  294. return err
  295. }
  296. a.scope.DefineTable(a.derivedTableInfo(ref))
  297. return nil
  298. }
  299. if cte, ok := a.scope.LookupTable(ref.Name); ok {
  300. a.scope.DefineTable(&TableInfo{
  301. Name: cte.Name,
  302. Columns: cte.Columns,
  303. Alias: ref.Alias,
  304. IsView: cte.IsView,
  305. })
  306. return nil
  307. }
  308. // A non-public schema qualifier selects a schema-qualified catalog entry.
  309. // Public tables are registered by bare name, so `public.t` resolves to `t`.
  310. catalogName := ref.Name
  311. if ref.Schema != "" && !strings.EqualFold(ref.Schema, "public") {
  312. // Qualified catalog relations are registered under their lowercase
  313. // schema-qualified name; schema names are case-insensitive here.
  314. catalogName = strings.ToLower(ref.Schema) + "." + strings.ToLower(ref.Name)
  315. }
  316. table, ok := a.catalog.GetTable(catalogName)
  317. if !ok {
  318. return &AnalysisError{
  319. Type: ErrTableNotFound,
  320. Message: fmt.Sprintf("table not found: %s", catalogName),
  321. }
  322. }
  323. a.scope.DefineTable(&TableInfo{
  324. Name: ref.Name,
  325. Columns: table.Columns,
  326. Alias: ref.Alias,
  327. IsView: table.IsView,
  328. })
  329. return nil
  330. }
  331. // derivedTableInfo builds the scope entry for a derived table. A compound
  332. // subquery (UNION/…) keeps its projection on the first leg. A wildcard expands
  333. // the columns of the subquery's source tables so callers can reference them.
  334. func (a *Analyzer) derivedTableInfo(ref parser.TableRef) *TableInfo {
  335. info := &TableInfo{Name: ref.Alias, Alias: ref.Alias}
  336. leg := firstSelectLeg(ref.Subquery)
  337. if leg == nil {
  338. return info
  339. }
  340. for _, col := range leg.Columns {
  341. if col.Star {
  342. for _, tref := range collectAllTableRefs(leg.From) {
  343. if t, ok := a.scope.LookupTable(tref.Name); ok {
  344. for _, c := range t.Columns {
  345. info.Columns = append(info.Columns, ColumnInfo{Name: c.Name, TableName: ref.Alias, Type: c.Type, Array: c.Array})
  346. }
  347. } else if t, ok := a.catalog.GetTable(tref.Name); ok {
  348. for _, c := range t.Columns {
  349. info.Columns = append(info.Columns, ColumnInfo{Name: c.Name, TableName: ref.Alias, Type: c.Type, Array: c.Array})
  350. }
  351. }
  352. }
  353. continue
  354. }
  355. name := ""
  356. switch {
  357. case col.Alias != "":
  358. name = col.Alias
  359. case col.Expr != nil:
  360. if colRef, ok := col.Expr.(*parser.ColumnRef); ok {
  361. name = colRef.Column
  362. }
  363. }
  364. if name == "" {
  365. name = fmt.Sprintf("col_%d", len(info.Columns))
  366. }
  367. info.Columns = append(info.Columns, ColumnInfo{Name: name, TableName: ref.Alias, Type: TypeAny})
  368. }
  369. return info
  370. }
  371. // collectAllTableRefs flattens a FROM list and its join chains.
  372. func collectAllTableRefs(from []parser.TableRef) []parser.TableRef {
  373. var refs []parser.TableRef
  374. var add func(parser.TableRef)
  375. add = func(ref parser.TableRef) {
  376. if ref.Subquery != nil {
  377. return
  378. }
  379. refs = append(refs, ref)
  380. if ref.Join != nil && ref.Join.Table != nil {
  381. add(*ref.Join.Table)
  382. }
  383. }
  384. for _, ref := range from {
  385. add(ref)
  386. }
  387. return refs
  388. }
  389. // cteTableInfo describes the columns a CTE exposes. The declared column list
  390. // wins; otherwise the anchor/first-leg projection names are used.
  391. func cteTableInfo(cte *parser.CTE) *TableInfo {
  392. leg := firstSelectLeg(cte.Query)
  393. info := &TableInfo{Name: cte.Name}
  394. if leg == nil {
  395. return info
  396. }
  397. for i, col := range leg.Columns {
  398. name := ""
  399. switch {
  400. case i < len(cte.Columns):
  401. name = cte.Columns[i]
  402. case col.Alias != "":
  403. name = col.Alias
  404. case col.Expr != nil:
  405. if ref, ok := col.Expr.(*parser.ColumnRef); ok {
  406. name = ref.Column
  407. }
  408. }
  409. if name == "" {
  410. name = fmt.Sprintf("col_%d", i)
  411. }
  412. info.Columns = append(info.Columns, ColumnInfo{
  413. Name: name,
  414. TableName: cte.Name,
  415. Type: TypeAny,
  416. })
  417. }
  418. return info
  419. }
  420. // firstSelectLeg returns the SELECT whose projection describes a (possibly
  421. // compound) subquery's output columns. A UNION/INTERSECT/EXCEPT keeps the
  422. // projection on its first leg.
  423. func firstSelectLeg(sel *parser.SelectStmt) *parser.SelectStmt {
  424. for sel != nil && sel.Compound != nil {
  425. sel = sel.Compound.Left
  426. }
  427. return sel
  428. }
  429. // validateTableStar checks that a qualified wildcard qualifier names a table or
  430. // alias present in scope, returning an error for unknown qualifiers instead of
  431. // silently falling back to a plain column expansion.
  432. func (a *Analyzer) validateTableStar(qualifier string) error {
  433. if _, ok := a.scope.LookupTable(qualifier); !ok {
  434. return &AnalysisError{
  435. Type: ErrTableNotFound,
  436. Message: fmt.Sprintf("no such table or alias: %s", qualifier),
  437. }
  438. }
  439. return nil
  440. }
  441. // resolveJoin resolves a JOIN clause.
  442. func (a *Analyzer) resolveJoin(join *parser.JoinClause) error {
  443. if join.Table == nil {
  444. return nil
  445. }
  446. if err := a.defineTableRef(*join.Table); err != nil {
  447. return err
  448. }
  449. // Analyze ON condition
  450. if join.Condition != nil {
  451. if _, err := a.analyzeExpr(join.Condition); err != nil {
  452. return err
  453. }
  454. }
  455. // Handle USING clause
  456. for _, colName := range join.Using {
  457. _, _, ok := a.scope.LookupColumn("", colName)
  458. if !ok {
  459. return &AnalysisError{
  460. Type: ErrColumnNotFound,
  461. Message: fmt.Sprintf("column not found in USING clause: %s", colName),
  462. }
  463. }
  464. }
  465. // Recursively handle chained JOINs
  466. if join.Table.Join != nil {
  467. if err := a.resolveJoin(join.Table.Join); err != nil {
  468. return err
  469. }
  470. }
  471. return nil
  472. }
  473. // analyzeInsert analyzes an INSERT statement.
  474. func (a *Analyzer) analyzeInsert(stmt *parser.InsertStmt) error {
  475. table, ok := a.catalog.GetTable(stmt.Table.Name)
  476. if !ok {
  477. return &AnalysisError{
  478. Type: ErrTableNotFound,
  479. Message: fmt.Sprintf("table not found: %s", stmt.Table.Name),
  480. }
  481. }
  482. a.scope.DefineTable(&TableInfo{Name: table.Name, Columns: table.Columns, IsView: table.IsView})
  483. // Validate column list if specified. Generated columns may never be written
  484. // explicitly.
  485. var targetCols []ColumnInfo
  486. if len(stmt.Columns) > 0 {
  487. for _, colName := range stmt.Columns {
  488. col, ok := table.GetColumn(colName)
  489. if !ok {
  490. return &AnalysisError{
  491. Type: ErrColumnNotFound,
  492. Message: fmt.Sprintf("column not found: %s", colName),
  493. }
  494. }
  495. if col.Generated {
  496. return &AnalysisError{
  497. Type: ErrTypeMismatch,
  498. Message: fmt.Sprintf("cannot INSERT into generated column %s", colName),
  499. }
  500. }
  501. targetCols = append(targetCols, *col)
  502. }
  503. } else {
  504. // Positional values map to the table's non-generated columns.
  505. for _, col := range table.Columns {
  506. if !col.Generated {
  507. targetCols = append(targetCols, col)
  508. }
  509. }
  510. }
  511. // An ON CONFLICT target names columns of the target table. An unknown name
  512. // must fail the statement rather than silently degrading to a scan. The
  513. // hidden rowid aliases are valid targets unless a real column shadows them.
  514. for _, colName := range stmt.ConflictTarget {
  515. if _, ok := table.GetColumn(colName); ok || isRowIDAlias(colName) {
  516. continue
  517. }
  518. return &AnalysisError{
  519. Type: ErrColumnNotFound,
  520. Message: fmt.Sprintf("column not found: %s", colName),
  521. }
  522. }
  523. // Validate VALUES. INSERT ... DEFAULT VALUES supplies no values at all, so
  524. // the placeholder empty row intentionally does not match the column count.
  525. // SQLite rejects the column-list form (INSERT INTO t (n) DEFAULT VALUES with
  526. // "0 values for 1 columns"); PizzaSQL accepts it and fills every column from
  527. // the schema defaults. This is a documented compatibility deviation.
  528. for _, row := range stmt.Values {
  529. if stmt.DefaultValues {
  530. continue
  531. }
  532. if len(row) != len(targetCols) {
  533. return &AnalysisError{
  534. Type: ErrTypeMismatch,
  535. Message: fmt.Sprintf("INSERT has %d columns but %d values", len(targetCols), len(row)),
  536. }
  537. }
  538. for _, expr := range row {
  539. _, err := a.analyzeExpr(expr)
  540. if err != nil {
  541. return err
  542. }
  543. }
  544. }
  545. // Analyze INSERT ... SELECT
  546. if stmt.Select != nil {
  547. if err := a.analyzeSelect(stmt.Select); err != nil {
  548. return err
  549. }
  550. }
  551. // Analyze RETURNING in the target table's scope.
  552. if err := a.analyzeReturning(stmt.Returning); err != nil {
  553. return err
  554. }
  555. return nil
  556. }
  557. // analyzeReturning validates a RETURNING projection. Wildcards are accepted; a
  558. // projection may not contain aggregates.
  559. func (a *Analyzer) analyzeReturning(cols []parser.SelectColumn) error {
  560. for _, col := range cols {
  561. if col.Star || col.TableStar != "" || col.Expr == nil {
  562. continue
  563. }
  564. info, err := a.analyzeExpr(col.Expr)
  565. if err != nil {
  566. return err
  567. }
  568. if info.IsAggregate {
  569. return &AnalysisError{
  570. Type: ErrAggregateInWhere,
  571. Message: "aggregate functions are not allowed in RETURNING",
  572. }
  573. }
  574. }
  575. return nil
  576. }
  577. // analyzeUpdate analyzes an UPDATE statement.
  578. func (a *Analyzer) analyzeUpdate(stmt *parser.UpdateStmt) error {
  579. table, ok := a.catalog.GetTable(stmt.Table.Name)
  580. if !ok {
  581. return &AnalysisError{
  582. Type: ErrTableNotFound,
  583. Message: fmt.Sprintf("table not found: %s", stmt.Table.Name),
  584. }
  585. }
  586. a.scope.DefineTable(&TableInfo{Name: table.Name, Columns: table.Columns, Alias: stmt.Table.Alias, IsView: table.IsView})
  587. // UPDATE ... FROM: source tables/derived tables join the target in scope so
  588. // SET and WHERE may reference their columns.
  589. if len(stmt.From) > 0 {
  590. if err := a.resolveFromClause(stmt.From); err != nil {
  591. return err
  592. }
  593. }
  594. // Validate SET assignments
  595. for _, assign := range stmt.Set {
  596. col, ok := table.GetColumn(assign.Column)
  597. if !ok {
  598. return &AnalysisError{
  599. Type: ErrColumnNotFound,
  600. Message: fmt.Sprintf("column not found: %s", assign.Column),
  601. }
  602. }
  603. if col.Generated {
  604. return &AnalysisError{
  605. Type: ErrTypeMismatch,
  606. Message: fmt.Sprintf("cannot UPDATE generated column %s", assign.Column),
  607. }
  608. }
  609. _, err := a.analyzeExpr(assign.Value)
  610. if err != nil {
  611. return err
  612. }
  613. }
  614. // Analyze WHERE clause
  615. if stmt.Where != nil {
  616. info, err := a.analyzeExpr(stmt.Where)
  617. if err != nil {
  618. return err
  619. }
  620. if info.IsAggregate {
  621. return &AnalysisError{
  622. Type: ErrAggregateInWhere,
  623. Message: "aggregate functions not allowed in WHERE clause",
  624. }
  625. }
  626. }
  627. if err := a.analyzeReturning(stmt.Returning); err != nil {
  628. return err
  629. }
  630. return nil
  631. }
  632. // analyzeDelete analyzes a DELETE statement.
  633. func (a *Analyzer) analyzeDelete(stmt *parser.DeleteStmt) error {
  634. table, ok := a.catalog.GetTable(stmt.Table.Name)
  635. if !ok {
  636. return &AnalysisError{
  637. Type: ErrTableNotFound,
  638. Message: fmt.Sprintf("table not found: %s", stmt.Table.Name),
  639. }
  640. }
  641. a.scope.DefineTable(&TableInfo{Name: table.Name, Columns: table.Columns, IsView: table.IsView})
  642. // Analyze WHERE clause
  643. if stmt.Where != nil {
  644. info, err := a.analyzeExpr(stmt.Where)
  645. if err != nil {
  646. return err
  647. }
  648. if info.IsAggregate {
  649. return &AnalysisError{
  650. Type: ErrAggregateInWhere,
  651. Message: "aggregate functions not allowed in WHERE clause",
  652. }
  653. }
  654. }
  655. if err := a.analyzeReturning(stmt.Returning); err != nil {
  656. return err
  657. }
  658. return nil
  659. }
  660. // analyzeCreateTable analyzes a CREATE TABLE statement.
  661. func (a *Analyzer) analyzeCreateTable(stmt *parser.CreateTableStmt) error {
  662. // Check if table already exists
  663. if a.catalog.TableExists(stmt.Table.Name) {
  664. if stmt.IfNotExists {
  665. return nil // Silently succeed
  666. }
  667. return &AnalysisError{
  668. Type: ErrTableExists,
  669. Message: fmt.Sprintf("table already exists: %s", stmt.Table.Name),
  670. }
  671. }
  672. // Build table info
  673. tableInfo := &TableInfo{
  674. Name: stmt.Table.Name,
  675. }
  676. columnNames := make(map[string]bool)
  677. for _, colDef := range stmt.Columns {
  678. upperName := strings.ToUpper(colDef.Name)
  679. if columnNames[upperName] {
  680. return &AnalysisError{
  681. Type: ErrColumnAmbiguous,
  682. Message: fmt.Sprintf("duplicate column name: %s", colDef.Name),
  683. }
  684. }
  685. columnNames[upperName] = true
  686. colInfo := ColumnInfo{
  687. Name: colDef.Name,
  688. Type: TypeFromName(colDef.Type.Name),
  689. Nullable: true,
  690. TableName: stmt.Table.Name,
  691. Generated: colDef.GeneratedExpr != nil,
  692. Array: colDef.Type.Array,
  693. }
  694. // Process constraints
  695. for _, constraint := range colDef.Constraints {
  696. switch constraint.Type {
  697. case parser.ConstraintPrimaryKey:
  698. colInfo.PrimaryKey = true
  699. colInfo.Nullable = false
  700. case parser.ConstraintNotNull:
  701. colInfo.Nullable = false
  702. case parser.ConstraintDefault:
  703. // Store default value (not evaluated here)
  704. colInfo.Default = constraint.Default
  705. }
  706. }
  707. tableInfo.Columns = append(tableInfo.Columns, colInfo)
  708. }
  709. // Process table-level constraints
  710. for _, constraint := range stmt.Constraints {
  711. switch constraint.Type {
  712. case parser.ConstraintPrimaryKey:
  713. for _, colName := range constraint.Columns {
  714. for i := range tableInfo.Columns {
  715. if strings.EqualFold(tableInfo.Columns[i].Name, colName) {
  716. tableInfo.Columns[i].PrimaryKey = true
  717. tableInfo.Columns[i].Nullable = false
  718. }
  719. }
  720. }
  721. }
  722. }
  723. // Validate generated-column expressions against the new table's columns.
  724. // Column references resolve within the table being created.
  725. for _, colDef := range stmt.Columns {
  726. if colDef.GeneratedExpr == nil {
  727. continue
  728. }
  729. genScope := NewScope(nil)
  730. genScope.DefineTable(tableInfo)
  731. oldScope := a.scope
  732. a.scope = genScope
  733. _, err := a.analyzeExpr(colDef.GeneratedExpr)
  734. a.scope = oldScope
  735. if err != nil {
  736. return err
  737. }
  738. }
  739. // Analysis is validation-only. Publishing the table before the durable
  740. // schema write can leave a phantom catalog entry when that write fails.
  741. return nil
  742. }
  743. // analyzeDropTable analyzes a DROP TABLE statement.
  744. func (a *Analyzer) analyzeDropTable(stmt *parser.DropTableStmt) error {
  745. for _, tableRef := range stmt.Tables {
  746. if !a.catalog.TableExists(tableRef.Name) {
  747. if stmt.IfExists {
  748. continue // Silently succeed
  749. }
  750. return &AnalysisError{
  751. Type: ErrTableNotFound,
  752. Message: fmt.Sprintf("table not found: %s", tableRef.Name),
  753. }
  754. }
  755. if err := a.catalog.DropTable(tableRef.Name); err != nil {
  756. return err
  757. }
  758. }
  759. return nil
  760. }
  761. // analyzeExpr analyzes an expression and returns type information.
  762. func (a *Analyzer) analyzeExpr(expr parser.Expr) (*ExprInfo, error) {
  763. switch e := expr.(type) {
  764. case *parser.LiteralExpr:
  765. return a.analyzeLiteral(e)
  766. case *parser.ColumnRef:
  767. return a.analyzeColumnRef(e)
  768. case *parser.BinaryExpr:
  769. return a.analyzeBinaryExpr(e)
  770. case *parser.UnaryExpr:
  771. return a.analyzeUnaryExpr(e)
  772. case *parser.FunctionCall:
  773. return a.analyzeFunctionCall(e)
  774. case *parser.ParenExpr:
  775. return a.analyzeExpr(e.Expr)
  776. case *parser.CaseExpr:
  777. return a.analyzeCaseExpr(e)
  778. case *parser.CastExpr:
  779. return a.analyzeCastExpr(e)
  780. case *parser.InExpr:
  781. return a.analyzeInExpr(e)
  782. case *parser.BetweenExpr:
  783. return a.analyzeBetweenExpr(e)
  784. case *parser.LikeExpr:
  785. return a.analyzeLikeExpr(e)
  786. case *parser.IsNullExpr:
  787. return a.analyzeIsNullExpr(e)
  788. case *parser.IsDistinctExpr:
  789. left, err := a.analyzeExpr(e.Left)
  790. if err != nil {
  791. return nil, err
  792. }
  793. right, err := a.analyzeExpr(e.Right)
  794. if err != nil {
  795. return nil, err
  796. }
  797. return &ExprInfo{
  798. Type: TypeBoolean,
  799. IsAggregate: left.IsAggregate || right.IsAggregate,
  800. Nullable: false,
  801. }, nil
  802. case *parser.ExistsExpr:
  803. return a.analyzeExistsExpr(e)
  804. case *parser.ArrayExpr:
  805. return a.analyzeArrayExpr(e)
  806. case *parser.SubscriptExpr:
  807. return a.analyzeSubscriptExpr(e)
  808. case *parser.AnyAllExpr:
  809. return a.analyzeAnyAllExpr(e)
  810. case *parser.SubqueryExpr:
  811. return a.analyzeSubqueryExpr(e)
  812. case *parser.WindowExpr:
  813. return a.analyzeWindowExpr(e)
  814. default:
  815. return &ExprInfo{Type: TypeUnknown}, nil
  816. }
  817. }
  818. // analyzeArrayExpr validates every element of an ARRAY[...] constructor.
  819. func (a *Analyzer) analyzeArrayExpr(e *parser.ArrayExpr) (*ExprInfo, error) {
  820. info := &ExprInfo{Type: TypeUnknown, Array: true}
  821. for _, element := range e.Elements {
  822. elementInfo, err := a.analyzeExpr(element)
  823. if err != nil {
  824. return nil, err
  825. }
  826. if elementInfo.IsAggregate {
  827. info.IsAggregate = true
  828. }
  829. if elementInfo.Nullable || element == nil {
  830. info.Nullable = true
  831. }
  832. if elementInfo.Type != TypeNull {
  833. info.Type = elementInfo.Type
  834. }
  835. }
  836. return info, nil
  837. }
  838. // analyzeSubscriptExpr validates the array expression and the index of arr[idx].
  839. func (a *Analyzer) analyzeSubscriptExpr(e *parser.SubscriptExpr) (*ExprInfo, error) {
  840. arrayInfo, err := a.analyzeExpr(e.Expr)
  841. if err != nil {
  842. return nil, err
  843. }
  844. indexInfo, err := a.analyzeExpr(e.Index)
  845. if err != nil {
  846. return nil, err
  847. }
  848. if indexInfo.Type != TypeUnknown && indexInfo.Type != TypeNull && !indexInfo.Type.IsNumeric() {
  849. return nil, &AnalysisError{
  850. Type: ErrTypeMismatch,
  851. Message: "array subscript must be an integer expression",
  852. }
  853. }
  854. return &ExprInfo{
  855. Type: arrayInfo.Type,
  856. IsAggregate: arrayInfo.IsAggregate || indexInfo.IsAggregate,
  857. Nullable: true,
  858. }, nil
  859. }
  860. // analyzeAnyAllExpr validates both sides of a quantified comparison.
  861. func (a *Analyzer) analyzeAnyAllExpr(e *parser.AnyAllExpr) (*ExprInfo, error) {
  862. leftInfo, err := a.analyzeExpr(e.Left)
  863. if err != nil {
  864. return nil, err
  865. }
  866. arrayInfo, err := a.analyzeExpr(e.Array)
  867. if err != nil {
  868. return nil, err
  869. }
  870. return &ExprInfo{
  871. Type: TypeBoolean,
  872. IsAggregate: leftInfo.IsAggregate || arrayInfo.IsAggregate,
  873. Nullable: true,
  874. }, nil
  875. }
  876. // analyzeWindowExpr analyzes a window function. Window functions are not
  877. // aggregates for the purpose of GROUP BY handling.
  878. func (a *Analyzer) analyzeWindowExpr(e *parser.WindowExpr) (*ExprInfo, error) {
  879. if e.Func != nil {
  880. for _, arg := range e.Func.Args {
  881. if _, err := a.analyzeExpr(arg); err != nil {
  882. return nil, err
  883. }
  884. }
  885. }
  886. for _, p := range e.PartitionBy {
  887. if _, err := a.analyzeExpr(p); err != nil {
  888. return nil, err
  889. }
  890. }
  891. for _, o := range e.OrderBy {
  892. if _, err := a.analyzeExpr(o.Expr); err != nil {
  893. return nil, err
  894. }
  895. }
  896. ret := TypeInteger
  897. if e.Func != nil {
  898. if sig, ok := builtinFunctions[e.Func.Name]; ok {
  899. ret = sig.ReturnType
  900. }
  901. }
  902. return &ExprInfo{Type: ret}, nil
  903. }
  904. func (a *Analyzer) analyzeLiteral(e *parser.LiteralExpr) (*ExprInfo, error) {
  905. info := &ExprInfo{IsConstant: true}
  906. switch e.Type {
  907. case lexer.TokenNumber:
  908. if strings.Contains(e.Value, ".") || strings.Contains(strings.ToLower(e.Value), "e") {
  909. info.Type = TypeReal
  910. } else {
  911. info.Type = TypeInteger
  912. }
  913. case lexer.TokenString:
  914. info.Type = TypeText
  915. case lexer.TokenBlob:
  916. info.Type = TypeBlob
  917. case lexer.TokenNULL:
  918. info.Type = TypeNull
  919. info.Nullable = true
  920. case lexer.TokenTRUE, lexer.TokenFALSE:
  921. info.Type = TypeBoolean
  922. case lexer.TokenStar:
  923. info.Type = TypeAny
  924. default:
  925. info.Type = TypeUnknown
  926. }
  927. return info, nil
  928. }
  929. func (a *Analyzer) analyzeColumnRef(e *parser.ColumnRef) (*ExprInfo, error) {
  930. col, _, ok := a.scope.LookupColumn(e.Table, e.Column)
  931. if !ok {
  932. // If no tables are in scope, treat as unknown (for standalone expressions)
  933. if len(a.scope.GetTables()) == 0 {
  934. return &ExprInfo{Type: TypeUnknown}, nil
  935. }
  936. // Hidden rowid alias (rowid/oid/_rowid_) when the table has no real column
  937. // of that name. LookupColumn already resolved a real column, so this only
  938. // fires for the alias (SQLite gives explicit columns precedence).
  939. if isRowIDAlias(e.Column) {
  940. if e.Table != "" {
  941. if _, found := a.scope.LookupTable(e.Table); !found {
  942. return nil, &AnalysisError{
  943. Type: ErrColumnNotFound,
  944. Message: fmt.Sprintf("column not found: %s", formatColumnRef(e)),
  945. }
  946. }
  947. }
  948. return &ExprInfo{Type: TypeInteger}, nil
  949. }
  950. return nil, &AnalysisError{
  951. Type: ErrColumnNotFound,
  952. Message: fmt.Sprintf("column not found: %s", formatColumnRef(e)),
  953. }
  954. }
  955. return &ExprInfo{
  956. Type: col.Type,
  957. Nullable: col.Nullable,
  958. Array: col.Array,
  959. }, nil
  960. }
  961. // isRowIDAlias reports whether a column name is a hidden rowid alias (rowid, oid,
  962. // or _rowid_), matching the storage layer's IsRowIDColumn.
  963. func isRowIDAlias(name string) bool {
  964. switch strings.ToLower(name) {
  965. case "rowid", "oid", "_rowid_":
  966. return true
  967. }
  968. return false
  969. }
  970. func formatColumnRef(e *parser.ColumnRef) string {
  971. if e.Table != "" {
  972. return e.Table + "." + e.Column
  973. }
  974. return e.Column
  975. }
  976. func (a *Analyzer) analyzeBinaryExpr(e *parser.BinaryExpr) (*ExprInfo, error) {
  977. left, err := a.analyzeExpr(e.Left)
  978. if err != nil {
  979. return nil, err
  980. }
  981. right, err := a.analyzeExpr(e.Right)
  982. if err != nil {
  983. return nil, err
  984. }
  985. info := &ExprInfo{
  986. IsAggregate: left.IsAggregate || right.IsAggregate,
  987. IsConstant: left.IsConstant && right.IsConstant,
  988. Nullable: left.Nullable || right.Nullable,
  989. }
  990. switch e.Op {
  991. case lexer.TokenMinus:
  992. // `jsonb - text`, `jsonb - integer`, and `jsonb - text[]` delete a key or
  993. // array element instead of subtracting. A jsonb right operand with any
  994. // other arithmetic operator stays a type error.
  995. if left.Type == TypeJSONB {
  996. if right.Type == TypeJSONB {
  997. return nil, &AnalysisError{
  998. Type: ErrTypeMismatch,
  999. Message: "jsonb deletion requires a text key, integer index, or text[] path, not a jsonb operand",
  1000. }
  1001. }
  1002. info.Type = TypeJSONB
  1003. return info, nil
  1004. }
  1005. if right.Type == TypeJSONB {
  1006. return nil, &AnalysisError{
  1007. Type: ErrTypeMismatch,
  1008. Message: "cannot subtract JSONB from a non-jsonb value",
  1009. }
  1010. }
  1011. fallthrough
  1012. case lexer.TokenPlus, lexer.TokenStar, lexer.TokenSlash, lexer.TokenPercent:
  1013. // Arithmetic operators. TypeAny comes from derived tables and CTEs whose
  1014. // column types are not tracked, so it is allowed rather than rejected.
  1015. info.Type = CommonType(left.Type, right.Type)
  1016. if !left.Type.IsNumeric() && left.Type != TypeNull && left.Type != TypeUnknown && left.Type != TypeAny {
  1017. return nil, &AnalysisError{
  1018. Type: ErrTypeMismatch,
  1019. Message: fmt.Sprintf("arithmetic operator requires numeric type, got %s", left.Type),
  1020. }
  1021. }
  1022. case lexer.TokenEq, lexer.TokenNeq, lexer.TokenLt, lexer.TokenLte, lexer.TokenGt, lexer.TokenGte:
  1023. // Comparison operators. A text literal is accepted against an array
  1024. // column: the runtime coerces and canonicalizes the literal to the
  1025. // column's array type, so `nums = '{3,4}'` compares arrays rather than
  1026. // INTEGER with TEXT.
  1027. info.Type = TypeBoolean
  1028. if !comparisonTypesCompatible(left, right) {
  1029. return nil, &AnalysisError{
  1030. Type: ErrTypeMismatch,
  1031. Message: fmt.Sprintf("cannot compare %s with %s", left.Type, right.Type),
  1032. }
  1033. }
  1034. case lexer.TokenBitAnd, lexer.TokenBitOr, lexer.TokenShiftLeft, lexer.TokenShiftRight:
  1035. // Bitwise operators coerce operands to integers.
  1036. info.Type = TypeInteger
  1037. for _, operand := range []Type{left.Type, right.Type} {
  1038. if !operand.IsNumeric() && operand != TypeNull && operand != TypeUnknown && operand != TypeAny {
  1039. return nil, &AnalysisError{
  1040. Type: ErrTypeMismatch,
  1041. Message: fmt.Sprintf("bitwise operator requires numeric type, got %s", operand),
  1042. }
  1043. }
  1044. }
  1045. case lexer.TokenAND, lexer.TokenOR:
  1046. // Logical operators
  1047. info.Type = TypeBoolean
  1048. case lexer.TokenConcat:
  1049. // String concatenation, or jsonb merge when either side is jsonb.
  1050. if left.Type == TypeJSONB || right.Type == TypeJSONB {
  1051. other := left.Type
  1052. if left.Type == TypeJSONB {
  1053. other = right.Type
  1054. }
  1055. if !jsonbTextOperand(other) {
  1056. return nil, &AnalysisError{
  1057. Type: ErrTypeMismatch,
  1058. Message: fmt.Sprintf("jsonb concatenation requires a jsonb or text operand, got %s", other),
  1059. }
  1060. }
  1061. info.Type = TypeJSONB
  1062. return info, nil
  1063. }
  1064. info.Type = TypeText
  1065. case lexer.TokenArrow:
  1066. // JSON extraction. A jsonb document extracts as jsonb, so a later
  1067. // comparison cannot silently reinterpret the result as SQL text.
  1068. info.Type = TypeAny
  1069. if left.Type == TypeJSONB {
  1070. info.Type = TypeJSONB
  1071. }
  1072. case lexer.TokenArrowText:
  1073. // ->> returns the SQL value or text; it is not jsonb.
  1074. info.Type = TypeAny
  1075. case lexer.TokenHashArrow:
  1076. // JSONB path extraction returns a JSONB value.
  1077. info.Type = TypeAny
  1078. if left.Type == TypeJSONB {
  1079. info.Type = TypeJSONB
  1080. }
  1081. case lexer.TokenHashArrowText:
  1082. info.Type = TypeText
  1083. case lexer.TokenHashMinus:
  1084. info.Type = TypeAny
  1085. if left.Type == TypeJSONB {
  1086. info.Type = TypeJSONB
  1087. }
  1088. case lexer.TokenAtArrow, lexer.TokenLtAt:
  1089. // Array containment compares two arrays element-wise. A jsonb
  1090. // containment needs a jsonb or text operand on both sides; a number is
  1091. // not silently reinterpreted as JSON.
  1092. if left.Array || right.Array {
  1093. if !comparisonTypesCompatible(left, right) {
  1094. return nil, &AnalysisError{
  1095. Type: ErrTypeMismatch,
  1096. Message: fmt.Sprintf("array containment requires two arrays, got %s and %s", left.Type, right.Type),
  1097. }
  1098. }
  1099. info.Type = TypeBoolean
  1100. return info, nil
  1101. }
  1102. if !jsonbTextOperand(left.Type) || !jsonbTextOperand(right.Type) {
  1103. return nil, &AnalysisError{
  1104. Type: ErrTypeMismatch,
  1105. Message: fmt.Sprintf("jsonb containment requires jsonb or text operands, got %s and %s", left.Type, right.Type),
  1106. }
  1107. }
  1108. info.Type = TypeBoolean
  1109. case lexer.TokenQuestion, lexer.TokenQuestionPipe, lexer.TokenQuestionAmp:
  1110. info.Type = TypeBoolean
  1111. default:
  1112. info.Type = TypeUnknown
  1113. }
  1114. return info, nil
  1115. }
  1116. // comparisonTypesCompatible reports whether two comparison operands can be
  1117. // compared. Arrays only compare with arrays or with text that can be read as
  1118. // array text, so `nums = '{3,4}'` is accepted while `nums = 5` is not.
  1119. func comparisonTypesCompatible(left, right *ExprInfo) bool {
  1120. if left.Array || right.Array {
  1121. return (left.Array && right.Array) || arrayLiteralComparison(left, right)
  1122. }
  1123. return left.Type.IsComparable(right.Type)
  1124. }
  1125. // arrayLiteralComparison reports whether one side is an array expression and the
  1126. // other is a text expression that can be read as array text.
  1127. func arrayLiteralComparison(left, right *ExprInfo) bool {
  1128. textCoercible := func(info *ExprInfo) bool {
  1129. switch info.Type {
  1130. case TypeText, TypeUnknown, TypeNull, TypeAny:
  1131. return true
  1132. default:
  1133. return false
  1134. }
  1135. }
  1136. return (left.Array && textCoercible(right)) || (right.Array && textCoercible(left))
  1137. }
  1138. // jsonbTextOperand reports whether a type can stand on the other side of a
  1139. // jsonb operator: a jsonb value or text that is read as a jsonb document.
  1140. func jsonbTextOperand(t Type) bool {
  1141. switch t {
  1142. case TypeJSONB, TypeText, TypeBlob, TypeNull, TypeUnknown, TypeAny:
  1143. return true
  1144. default:
  1145. return false
  1146. }
  1147. }
  1148. func (a *Analyzer) analyzeUnaryExpr(e *parser.UnaryExpr) (*ExprInfo, error) {
  1149. operand, err := a.analyzeExpr(e.Operand)
  1150. if err != nil {
  1151. return nil, err
  1152. }
  1153. info := &ExprInfo{
  1154. IsAggregate: operand.IsAggregate,
  1155. IsConstant: operand.IsConstant,
  1156. Nullable: operand.Nullable,
  1157. }
  1158. switch e.Op {
  1159. case lexer.TokenPlus:
  1160. // Unary + is a no-op in SQLite — passes any type through unchanged.
  1161. info.Type = operand.Type
  1162. case lexer.TokenMinus:
  1163. info.Type = operand.Type
  1164. if !operand.Type.IsNumeric() && operand.Type != TypeNull && operand.Type != TypeUnknown {
  1165. return nil, &AnalysisError{
  1166. Type: ErrTypeMismatch,
  1167. Message: fmt.Sprintf("unary - requires numeric type, got %s", operand.Type),
  1168. }
  1169. }
  1170. case lexer.TokenNOT:
  1171. info.Type = TypeBoolean
  1172. case lexer.TokenBitNot:
  1173. info.Type = TypeInteger
  1174. default:
  1175. info.Type = operand.Type
  1176. }
  1177. return info, nil
  1178. }
  1179. // tableFunctionColumns reports the output columns of a set-returning function
  1180. // used as the single FROM item, using PostgreSQL's column names.
  1181. func tableFunctionColumns(name string) []ColumnInfo {
  1182. switch strings.ToLower(name) {
  1183. case "jsonb_each", "jsonb_each_text":
  1184. valueType := TypeJSONB
  1185. if strings.EqualFold(name, "jsonb_each_text") {
  1186. valueType = TypeText
  1187. }
  1188. return []ColumnInfo{
  1189. {Name: "key", Type: TypeText, Nullable: true, TableName: name},
  1190. {Name: "value", Type: valueType, Nullable: true, TableName: name},
  1191. }
  1192. case "jsonb_array_elements":
  1193. return []ColumnInfo{{Name: "value", Type: TypeJSONB, Nullable: true, TableName: name}}
  1194. case "jsonb_array_elements_text":
  1195. return []ColumnInfo{{Name: "value", Type: TypeText, Nullable: true, TableName: name}}
  1196. case "jsonb_object_keys":
  1197. return []ColumnInfo{{Name: "jsonb_object_keys", Type: TypeText, Nullable: true, TableName: name}}
  1198. default:
  1199. // unnest() produces one column with the function's name, matching
  1200. // PostgreSQL's output column name.
  1201. return []ColumnInfo{{Name: strings.ToLower(name), Type: TypeAny, Nullable: true, TableName: name}}
  1202. }
  1203. }
  1204. func (a *Analyzer) analyzeFunctionCall(e *parser.FunctionCall) (*ExprInfo, error) {
  1205. sig, ok := LookupFunction(e.Name)
  1206. if !ok {
  1207. return nil, &AnalysisError{
  1208. Type: ErrInvalidFunction,
  1209. Message: fmt.Sprintf("unknown function: %s", e.Name),
  1210. }
  1211. }
  1212. // Handle COUNT(*)
  1213. argCount := len(e.Args)
  1214. if e.Star {
  1215. argCount = 0 // COUNT(*) has 0 real args
  1216. }
  1217. // Check argument count
  1218. if argCount < sig.MinArgs {
  1219. return nil, &AnalysisError{
  1220. Type: ErrInvalidArgCount,
  1221. Message: fmt.Sprintf("function %s requires at least %d arguments, got %d", e.Name, sig.MinArgs, argCount),
  1222. }
  1223. }
  1224. if sig.MaxArgs >= 0 && argCount > sig.MaxArgs {
  1225. return nil, &AnalysisError{
  1226. Type: ErrInvalidArgCount,
  1227. Message: fmt.Sprintf("function %s accepts at most %d arguments, got %d", e.Name, sig.MaxArgs, argCount),
  1228. }
  1229. }
  1230. // Analyze arguments
  1231. info := &ExprInfo{
  1232. Type: sig.ReturnType,
  1233. IsAggregate: sig.IsAggregate,
  1234. }
  1235. for _, arg := range e.Args {
  1236. argInfo, err := a.analyzeExpr(arg)
  1237. if err != nil {
  1238. return nil, err
  1239. }
  1240. if argInfo.Nullable {
  1241. info.Nullable = true
  1242. }
  1243. // Propagate aggregate status from arguments
  1244. if argInfo.IsAggregate && !sig.IsAggregate {
  1245. info.IsAggregate = true
  1246. }
  1247. }
  1248. // Special case: polymorphic functions (MIN/MAX/COALESCE/...) return a value
  1249. // whose type follows their first argument.
  1250. if sig.ReturnType == TypeAny && len(e.Args) > 0 && isPolymorphicFunction(e.Name) {
  1251. argInfo, _ := a.analyzeExpr(e.Args[0])
  1252. if argInfo != nil {
  1253. info.Type = argInfo.Type
  1254. info.Array = argInfo.Array
  1255. info.Nullable = argInfo.Nullable
  1256. }
  1257. }
  1258. return info, nil
  1259. }
  1260. // isPolymorphicFunction reports whether a function's result type follows its
  1261. // first argument rather than a fixed signature type.
  1262. func isPolymorphicFunction(name string) bool {
  1263. switch strings.ToUpper(name) {
  1264. case "MIN", "MAX", "COALESCE", "IFNULL", "NVL", "NULLIF", "IIF", "PIZZASQL_PARAM":
  1265. return true
  1266. }
  1267. return false
  1268. }
  1269. func (a *Analyzer) analyzeCaseExpr(e *parser.CaseExpr) (*ExprInfo, error) {
  1270. info := &ExprInfo{
  1271. Nullable: true, // CASE can return NULL
  1272. }
  1273. // Analyze operand if present (simple CASE)
  1274. if e.Operand != nil {
  1275. opInfo, err := a.analyzeExpr(e.Operand)
  1276. if err != nil {
  1277. return nil, err
  1278. }
  1279. if opInfo.IsAggregate {
  1280. info.IsAggregate = true
  1281. }
  1282. }
  1283. // Analyze WHEN clauses
  1284. var resultType Type
  1285. for _, when := range e.Whens {
  1286. condInfo, err := a.analyzeExpr(when.Condition)
  1287. if err != nil {
  1288. return nil, err
  1289. }
  1290. if condInfo.IsAggregate {
  1291. info.IsAggregate = true
  1292. }
  1293. resInfo, err := a.analyzeExpr(when.Result)
  1294. if err != nil {
  1295. return nil, err
  1296. }
  1297. if resInfo.IsAggregate {
  1298. info.IsAggregate = true
  1299. }
  1300. if resultType == TypeUnknown {
  1301. resultType = resInfo.Type
  1302. } else {
  1303. resultType = CommonType(resultType, resInfo.Type)
  1304. }
  1305. }
  1306. // Analyze ELSE clause
  1307. if e.Else != nil {
  1308. elseInfo, err := a.analyzeExpr(e.Else)
  1309. if err != nil {
  1310. return nil, err
  1311. }
  1312. if elseInfo.IsAggregate {
  1313. info.IsAggregate = true
  1314. }
  1315. resultType = CommonType(resultType, elseInfo.Type)
  1316. }
  1317. info.Type = resultType
  1318. return info, nil
  1319. }
  1320. func (a *Analyzer) analyzeCastExpr(e *parser.CastExpr) (*ExprInfo, error) {
  1321. exprInfo, err := a.analyzeExpr(e.Expr)
  1322. if err != nil {
  1323. return nil, err
  1324. }
  1325. return &ExprInfo{
  1326. Type: TypeFromName(e.Type.Name),
  1327. IsAggregate: exprInfo.IsAggregate,
  1328. IsConstant: exprInfo.IsConstant,
  1329. Nullable: exprInfo.Nullable,
  1330. Array: e.Type.Array,
  1331. }, nil
  1332. }
  1333. func (a *Analyzer) analyzeInExpr(e *parser.InExpr) (*ExprInfo, error) {
  1334. leftInfo, err := a.analyzeExpr(e.Left)
  1335. if err != nil {
  1336. return nil, err
  1337. }
  1338. info := &ExprInfo{
  1339. Type: TypeBoolean,
  1340. IsAggregate: leftInfo.IsAggregate,
  1341. }
  1342. // Analyze value list
  1343. for _, val := range e.Values {
  1344. valInfo, err := a.analyzeExpr(val)
  1345. if err != nil {
  1346. return nil, err
  1347. }
  1348. if valInfo.IsAggregate {
  1349. info.IsAggregate = true
  1350. }
  1351. }
  1352. // Analyze subquery
  1353. if e.Subquery != nil {
  1354. subScope := NewScope(a.scope)
  1355. oldScope := a.scope
  1356. a.scope = subScope
  1357. err := a.analyzeSelect(e.Subquery)
  1358. a.scope = oldScope
  1359. if err != nil {
  1360. return nil, err
  1361. }
  1362. }
  1363. return info, nil
  1364. }
  1365. func (a *Analyzer) analyzeBetweenExpr(e *parser.BetweenExpr) (*ExprInfo, error) {
  1366. leftInfo, err := a.analyzeExpr(e.Left)
  1367. if err != nil {
  1368. return nil, err
  1369. }
  1370. lowInfo, err := a.analyzeExpr(e.Low)
  1371. if err != nil {
  1372. return nil, err
  1373. }
  1374. highInfo, err := a.analyzeExpr(e.High)
  1375. if err != nil {
  1376. return nil, err
  1377. }
  1378. return &ExprInfo{
  1379. Type: TypeBoolean,
  1380. IsAggregate: leftInfo.IsAggregate || lowInfo.IsAggregate || highInfo.IsAggregate,
  1381. Nullable: leftInfo.Nullable || lowInfo.Nullable || highInfo.Nullable,
  1382. }, nil
  1383. }
  1384. func (a *Analyzer) analyzeLikeExpr(e *parser.LikeExpr) (*ExprInfo, error) {
  1385. leftInfo, err := a.analyzeExpr(e.Left)
  1386. if err != nil {
  1387. return nil, err
  1388. }
  1389. patternInfo, err := a.analyzeExpr(e.Pattern)
  1390. if err != nil {
  1391. return nil, err
  1392. }
  1393. info := &ExprInfo{
  1394. Type: TypeBoolean,
  1395. IsAggregate: leftInfo.IsAggregate || patternInfo.IsAggregate,
  1396. Nullable: leftInfo.Nullable || patternInfo.Nullable,
  1397. }
  1398. if e.Escape != nil {
  1399. escInfo, err := a.analyzeExpr(e.Escape)
  1400. if err != nil {
  1401. return nil, err
  1402. }
  1403. if escInfo.IsAggregate {
  1404. info.IsAggregate = true
  1405. }
  1406. }
  1407. return info, nil
  1408. }
  1409. func (a *Analyzer) analyzeIsNullExpr(e *parser.IsNullExpr) (*ExprInfo, error) {
  1410. leftInfo, err := a.analyzeExpr(e.Left)
  1411. if err != nil {
  1412. return nil, err
  1413. }
  1414. return &ExprInfo{
  1415. Type: TypeBoolean,
  1416. IsAggregate: leftInfo.IsAggregate,
  1417. IsConstant: leftInfo.IsConstant,
  1418. }, nil
  1419. }
  1420. func (a *Analyzer) analyzeExistsExpr(e *parser.ExistsExpr) (*ExprInfo, error) {
  1421. // Analyze subquery in its own scope
  1422. subScope := NewScope(a.scope)
  1423. oldScope := a.scope
  1424. a.scope = subScope
  1425. err := a.analyzeSelect(e.Subquery)
  1426. a.scope = oldScope
  1427. if err != nil {
  1428. return nil, err
  1429. }
  1430. return &ExprInfo{
  1431. Type: TypeBoolean,
  1432. }, nil
  1433. }
  1434. func (a *Analyzer) analyzeSubqueryExpr(e *parser.SubqueryExpr) (*ExprInfo, error) {
  1435. // Analyze subquery in its own scope
  1436. subScope := NewScope(a.scope)
  1437. oldScope := a.scope
  1438. a.scope = subScope
  1439. err := a.analyzeSelect(e.Query)
  1440. a.scope = oldScope
  1441. if err != nil {
  1442. return nil, err
  1443. }
  1444. // Scalar subquery - return type of first column
  1445. // For simplicity, return TypeAny
  1446. return &ExprInfo{
  1447. Type: TypeAny,
  1448. }, nil
  1449. }