parser.go 86 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516
  1. package parser
  2. import (
  3. "strings"
  4. "github.com/danfragoso/pizzasql-next/pkg/lexer"
  5. "github.com/danfragoso/pizzasql-next/pkg/pgerror"
  6. )
  7. // Parser parses SQL statements into an AST.
  8. type Parser struct {
  9. lexer *lexer.Lexer
  10. curToken lexer.Token
  11. peekToken lexer.Token
  12. errors []*ParseError
  13. }
  14. // New creates a new Parser.
  15. func New(l *lexer.Lexer) *Parser {
  16. p := &Parser{lexer: l}
  17. // Read two tokens to initialize curToken and peekToken
  18. p.nextToken()
  19. p.nextToken()
  20. return p
  21. }
  22. // Parse parses a SQL statement.
  23. func (p *Parser) Parse() (Statement, error) {
  24. stmt, err := p.parseStatement()
  25. if err != nil {
  26. return nil, err
  27. }
  28. // Consume optional semicolon
  29. if p.curTokenIs(lexer.TokenSemicolon) {
  30. p.nextToken()
  31. }
  32. if !p.curTokenIs(lexer.TokenEOF) {
  33. return nil, p.curError("unexpected trailing token: " + p.curToken.Type.String())
  34. }
  35. return stmt, nil
  36. }
  37. // ParseExpr parses a standalone SQL expression, used for persisted generated
  38. // column and expression-index definitions. It rejects trailing tokens so a
  39. // malformed stored expression surfaces immediately.
  40. func ParseExpr(input string) (Expr, error) {
  41. p := New(lexer.New(input))
  42. expr, err := p.parseExpr()
  43. if err != nil {
  44. return nil, err
  45. }
  46. if !p.curTokenIs(lexer.TokenEOF) {
  47. return nil, p.curError("unexpected trailing token: " + p.curToken.Type.String())
  48. }
  49. return expr, nil
  50. }
  51. // ParseMultiple parses multiple SQL statements.
  52. func (p *Parser) ParseMultiple() ([]Statement, error) {
  53. var stmts []Statement
  54. for !p.curTokenIs(lexer.TokenEOF) {
  55. stmt, err := p.parseStatement()
  56. if err != nil {
  57. return nil, err
  58. }
  59. stmts = append(stmts, stmt)
  60. // Consume optional semicolon
  61. if p.curTokenIs(lexer.TokenSemicolon) {
  62. p.nextToken()
  63. }
  64. }
  65. return stmts, nil
  66. }
  67. func (p *Parser) nextToken() {
  68. p.curToken = p.peekToken
  69. p.peekToken = p.lexer.NextToken()
  70. // Skip comments
  71. for p.peekToken.Type == lexer.TokenComment {
  72. p.peekToken = p.lexer.NextToken()
  73. }
  74. }
  75. func (p *Parser) curTokenIs(t lexer.TokenType) bool {
  76. return p.curToken.Type == t
  77. }
  78. func (p *Parser) peekTokenIs(t lexer.TokenType) bool {
  79. return p.peekToken.Type == t
  80. }
  81. func (p *Parser) expectPeek(t lexer.TokenType) error {
  82. if p.peekTokenIs(t) {
  83. p.nextToken()
  84. return nil
  85. }
  86. return p.peekError(t)
  87. }
  88. // curIdentIs reports whether the current token is an identifier spelling word
  89. // case-insensitively. It lets context-sensitive keywords (GENERATED, ALWAYS,
  90. // STORED, VIRTUAL) be recognized only in the positions where they are
  91. // meaningful, so they remain usable as ordinary identifiers elsewhere.
  92. func (p *Parser) curIdentIs(word string) bool {
  93. return p.curToken.Type == lexer.TokenIdent && strings.EqualFold(p.curToken.Literal, word)
  94. }
  95. func (p *Parser) peekError(t lexer.TokenType) error {
  96. return newError(
  97. "expected "+t.String()+", got "+p.peekToken.Type.String(),
  98. p.peekToken.Line,
  99. p.peekToken.Column,
  100. p.peekToken.Literal,
  101. )
  102. }
  103. func (p *Parser) curError(msg string) error {
  104. return newError(
  105. msg,
  106. p.curToken.Line,
  107. p.curToken.Column,
  108. p.curToken.Literal,
  109. )
  110. }
  111. func (p *Parser) parseStatement() (Statement, error) {
  112. if p.isWithStart() {
  113. return p.parseWithStatement()
  114. }
  115. // LISTEN, UNLISTEN, and NOTIFY are contextual keywords: they remain valid
  116. // identifiers in expressions and only denote a statement at the start of a
  117. // statement. That keeps existing columns named "notify" working.
  118. if p.curTokenIs(lexer.TokenIdent) {
  119. switch strings.ToUpper(p.curToken.Literal) {
  120. case "LISTEN":
  121. return p.parseListen()
  122. case "UNLISTEN":
  123. return p.parseUnlisten()
  124. case "NOTIFY":
  125. return p.parseNotify()
  126. case "SHOW":
  127. return p.parseShow()
  128. }
  129. }
  130. switch p.curToken.Type {
  131. case lexer.TokenSELECT:
  132. return p.parseSelect()
  133. case lexer.TokenINSERT:
  134. return p.parseInsert()
  135. case lexer.TokenUPDATE:
  136. return p.parseUpdate()
  137. case lexer.TokenDELETE:
  138. return p.parseDelete()
  139. case lexer.TokenCREATE:
  140. return p.parseCreate()
  141. case lexer.TokenDROP:
  142. return p.parseDrop()
  143. case lexer.TokenALTER:
  144. return p.parseAlter()
  145. case lexer.TokenATTACH:
  146. return p.parseAttach()
  147. case lexer.TokenDETACH:
  148. return p.parseDetach()
  149. case lexer.TokenPRAGMA:
  150. return p.parsePragma()
  151. case lexer.TokenSET:
  152. return p.parseSet()
  153. case lexer.TokenANALYZE:
  154. return p.parseAnalyze()
  155. case lexer.TokenEXPLAIN:
  156. return p.parseExplain()
  157. case lexer.TokenBEGIN:
  158. return p.parseBegin()
  159. case lexer.TokenCOMMIT:
  160. return p.parseCommit()
  161. case lexer.TokenROLLBACK:
  162. return p.parseRollback()
  163. case lexer.TokenSAVEPOINT:
  164. return p.parseSavepoint()
  165. case lexer.TokenRELEASE:
  166. return p.parseRelease()
  167. default:
  168. return nil, p.curError("unexpected token: " + p.curToken.Type.String())
  169. }
  170. }
  171. // parseSingleSelectTerm parses one SELECT body (SELECT … FROM … WHERE … GROUP BY … HAVING …)
  172. // but stops before any set operator, ORDER BY, LIMIT, or OFFSET.
  173. // Callers that want the full chain (including set ops) use parseSelect instead.
  174. func (p *Parser) parseSingleSelectTerm() (*SelectStmt, error) {
  175. stmt := &SelectStmt{}
  176. p.nextToken() // consume SELECT
  177. // Check for DISTINCT / ALL
  178. if p.curTokenIs(lexer.TokenDISTINCT) {
  179. stmt.Distinct = true
  180. p.nextToken()
  181. } else if p.curTokenIs(lexer.TokenALL) {
  182. p.nextToken()
  183. }
  184. cols, err := p.parseSelectColumns()
  185. if err != nil {
  186. return nil, err
  187. }
  188. stmt.Columns = cols
  189. if p.curTokenIs(lexer.TokenFROM) {
  190. p.nextToken()
  191. tables, err := p.parseTableRefs()
  192. if err != nil {
  193. return nil, err
  194. }
  195. stmt.From = tables
  196. }
  197. if p.curTokenIs(lexer.TokenWHERE) {
  198. p.nextToken()
  199. where, err := p.parseExpr()
  200. if err != nil {
  201. return nil, err
  202. }
  203. stmt.Where = where
  204. }
  205. if p.curTokenIs(lexer.TokenGROUP) {
  206. if err := p.expectPeek(lexer.TokenBY); err != nil {
  207. return nil, err
  208. }
  209. p.nextToken()
  210. groupBy, err := p.parseExprList()
  211. if err != nil {
  212. return nil, err
  213. }
  214. stmt.GroupBy = groupBy
  215. }
  216. if p.curTokenIs(lexer.TokenHAVING) {
  217. p.nextToken()
  218. having, err := p.parseExpr()
  219. if err != nil {
  220. return nil, err
  221. }
  222. stmt.Having = having
  223. }
  224. return stmt, nil
  225. }
  226. // parseSelect parses a SELECT statement, including any trailing set operations
  227. // (UNION / INTERSECT / EXCEPT) and an optional ORDER BY / LIMIT / OFFSET.
  228. func (p *Parser) parseSelect() (*SelectStmt, error) {
  229. stmt, err := p.parseSingleSelectTerm()
  230. if err != nil {
  231. return nil, err
  232. }
  233. // Handle set operations: UNION [ALL], INTERSECT, EXCEPT
  234. if p.curTokenIs(lexer.TokenUNION) || p.curTokenIs(lexer.TokenINTERSECT) || p.curTokenIs(lexer.TokenEXCEPT) {
  235. compound, err := p.parseCompoundChain(stmt)
  236. if err != nil {
  237. return nil, err
  238. }
  239. return &SelectStmt{Compound: compound}, nil
  240. }
  241. // Parse ORDER BY clause
  242. if p.curTokenIs(lexer.TokenORDER) {
  243. if err := p.expectPeek(lexer.TokenBY); err != nil {
  244. return nil, err
  245. }
  246. p.nextToken()
  247. orderBy, err := p.parseOrderBy()
  248. if err != nil {
  249. return nil, err
  250. }
  251. stmt.OrderBy = orderBy
  252. }
  253. // Parse LIMIT clause
  254. if p.curTokenIs(lexer.TokenLIMIT) {
  255. p.nextToken()
  256. limit, err := p.parseExpr()
  257. if err != nil {
  258. return nil, err
  259. }
  260. stmt.Limit = limit
  261. }
  262. // Parse OFFSET clause
  263. if p.curTokenIs(lexer.TokenOFFSET) {
  264. p.nextToken()
  265. offset, err := p.parseExpr()
  266. if err != nil {
  267. return nil, err
  268. }
  269. stmt.Offset = offset
  270. }
  271. locking, err := p.parseLockingClause()
  272. if err != nil {
  273. return nil, err
  274. }
  275. stmt.Locking = locking
  276. return stmt, nil
  277. }
  278. // setOpPrec returns the precedence of a set operator token.
  279. // INTERSECT binds more tightly than UNION/EXCEPT per SQL standard.
  280. func setOpPrec(t lexer.TokenType) int {
  281. if t == lexer.TokenINTERSECT {
  282. return 2
  283. }
  284. return 1
  285. }
  286. // parseCompoundChain collects all set-op legs and builds a left-associative tree
  287. // respecting INTERSECT > UNION/EXCEPT precedence.
  288. //
  289. // The algorithm is the standard precedence-climbing / Pratt approach:
  290. //
  291. // parseMin(minPrec):
  292. // left = first already-parsed SELECT (passed in as `first`)
  293. // while curOp.prec >= minPrec:
  294. // op = curOp; consume op
  295. // right = parseSingleSelect()
  296. // while nextOp.prec > op.prec: // right-bind tighter ops
  297. // right = parseMin(op.prec+1) using right as seed
  298. // left = Compound(left, op, right)
  299. // return left
  300. func (p *Parser) parseCompoundChain(first *SelectStmt) (*CompoundSelect, error) {
  301. type leg struct {
  302. op SetOpType
  303. query *SelectStmt
  304. }
  305. // Consume a set-op token and return its SetOpType + precedence.
  306. consumeOp := func() (SetOpType, int, error) {
  307. switch p.curToken.Type {
  308. case lexer.TokenUNION:
  309. p.nextToken()
  310. if p.curTokenIs(lexer.TokenALL) {
  311. p.nextToken()
  312. return SetOpUnionAll, 1, nil
  313. }
  314. return SetOpUnion, 1, nil
  315. case lexer.TokenINTERSECT:
  316. p.nextToken()
  317. return SetOpIntersect, 2, nil
  318. case lexer.TokenEXCEPT:
  319. p.nextToken()
  320. return SetOpExcept, 1, nil
  321. }
  322. return 0, 0, p.curError("expected UNION, INTERSECT, or EXCEPT")
  323. }
  324. isSetOp := func() bool {
  325. return p.curTokenIs(lexer.TokenUNION) ||
  326. p.curTokenIs(lexer.TokenINTERSECT) ||
  327. p.curTokenIs(lexer.TokenEXCEPT)
  328. }
  329. // parseSingleSelect parses the next SELECT term (no set-ops claimed).
  330. parseSingleSelect := func() (*SelectStmt, error) {
  331. if !p.curTokenIs(lexer.TokenSELECT) {
  332. return nil, p.curError("expected SELECT after set operator")
  333. }
  334. return p.parseSingleSelectTerm()
  335. }
  336. // Precedence-climbing: build left-to-right tree, INTERSECT binds tighter.
  337. var climb func(left *SelectStmt, minPrec int) (*CompoundSelect, error)
  338. climb = func(left *SelectStmt, minPrec int) (*CompoundSelect, error) {
  339. for isSetOp() && setOpPrec(p.curToken.Type) >= minPrec {
  340. op, prec, err := consumeOp()
  341. if err != nil {
  342. return nil, err
  343. }
  344. right, err := parseSingleSelect()
  345. if err != nil {
  346. return nil, err
  347. }
  348. // If the right node itself resolved to a compound (via recursive parseSelect),
  349. // unwrap and re-climb properly.
  350. if right.Compound != nil {
  351. // right was a sub-chain; treat it as already climbed.
  352. } else {
  353. // Absorb any higher-precedence ops on the right.
  354. for isSetOp() && setOpPrec(p.curToken.Type) > prec {
  355. sub, err := climb(right, prec+1)
  356. if err != nil {
  357. return nil, err
  358. }
  359. right = &SelectStmt{Compound: sub}
  360. break
  361. }
  362. }
  363. node := &CompoundSelect{Left: left, Op: op, Right: right}
  364. left = &SelectStmt{Compound: node}
  365. }
  366. if left.Compound != nil {
  367. return left.Compound, nil
  368. }
  369. return nil, p.curError("internal: no compound built")
  370. }
  371. compound, err := climb(first, 1)
  372. if err != nil {
  373. return nil, err
  374. }
  375. // Parse trailing ORDER BY / LIMIT / OFFSET that apply to the whole compound.
  376. if p.curTokenIs(lexer.TokenORDER) {
  377. if err := p.expectPeek(lexer.TokenBY); err != nil {
  378. return nil, err
  379. }
  380. p.nextToken()
  381. orderBy, err := p.parseOrderBy()
  382. if err != nil {
  383. return nil, err
  384. }
  385. compound.OrderBy = orderBy
  386. }
  387. if p.curTokenIs(lexer.TokenLIMIT) {
  388. p.nextToken()
  389. limit, err := p.parseExpr()
  390. if err != nil {
  391. return nil, err
  392. }
  393. compound.Limit = limit
  394. }
  395. if p.curTokenIs(lexer.TokenOFFSET) {
  396. p.nextToken()
  397. offset, err := p.parseExpr()
  398. if err != nil {
  399. return nil, err
  400. }
  401. compound.Offset = offset
  402. }
  403. if p.isLockingClauseStart() {
  404. return nil, pgerror.Unsupported("row locking is not supported on a compound SELECT")
  405. }
  406. return compound, nil
  407. }
  408. func (p *Parser) parseSelectColumns() ([]SelectColumn, error) {
  409. var cols []SelectColumn
  410. for {
  411. col := SelectColumn{}
  412. if p.curTokenIs(lexer.TokenStar) {
  413. col.Star = true
  414. p.nextToken()
  415. } else {
  416. expr, err := p.parseExpr()
  417. if err != nil {
  418. return nil, err
  419. }
  420. // Qualified wildcard (table.*): the expression grammar parses this as
  421. // ColumnRef{Table: table, Column: "*"}. Lift it into a scoped wildcard
  422. // projection instead of a column reference literally named "*".
  423. if ref, ok := expr.(*ColumnRef); ok && ref.Table != "" && ref.Column == "*" {
  424. col.TableStar = ref.Table
  425. } else {
  426. col.Expr = expr
  427. // Check for AS alias
  428. if p.curTokenIs(lexer.TokenAS) {
  429. p.nextToken()
  430. if !p.curTokenIs(lexer.TokenIdent) {
  431. return nil, p.curError("expected identifier after AS")
  432. }
  433. col.Alias = p.curToken.Literal
  434. p.nextToken()
  435. } else if p.curTokenIs(lexer.TokenIdent) {
  436. // Alias without AS
  437. col.Alias = p.curToken.Literal
  438. p.nextToken()
  439. }
  440. }
  441. }
  442. cols = append(cols, col)
  443. if !p.curTokenIs(lexer.TokenComma) {
  444. break
  445. }
  446. p.nextToken() // consume comma
  447. }
  448. return cols, nil
  449. }
  450. func (p *Parser) parseTableRefs() ([]TableRef, error) {
  451. var tables []TableRef
  452. table, err := p.parseTableRef(true)
  453. if err != nil {
  454. return nil, err
  455. }
  456. tables = append(tables, *table)
  457. // Parse JOINs or comma-separated tables
  458. for {
  459. if p.curTokenIs(lexer.TokenComma) {
  460. p.nextToken()
  461. table, err := p.parseTableRef(true)
  462. if err != nil {
  463. return nil, err
  464. }
  465. tables = append(tables, *table)
  466. } else if p.isJoinKeyword() {
  467. join, err := p.parseJoin()
  468. if err != nil {
  469. return nil, err
  470. }
  471. // Find the last Join in the chain and attach new join there
  472. lastTable := &tables[len(tables)-1]
  473. if lastTable.Join == nil {
  474. lastTable.Join = join
  475. } else {
  476. // Find the end of the join chain
  477. current := lastTable.Join
  478. for current.Table != nil && current.Table.Join != nil {
  479. current = current.Table.Join
  480. }
  481. // Attach to the end of the chain
  482. if current.Table != nil {
  483. current.Table.Join = join
  484. }
  485. }
  486. } else {
  487. break
  488. }
  489. }
  490. for _, table := range tables {
  491. if table.Function == nil {
  492. continue
  493. }
  494. if len(tables) > 1 || table.Join != nil {
  495. return nil, pgerror.Unsupported("a table function in FROM must be the only table reference; joins around a table function are not supported")
  496. }
  497. }
  498. return tables, nil
  499. }
  500. func (p *Parser) parseTableRef(allowFunction bool) (*TableRef, error) {
  501. ref := &TableRef{}
  502. // Check for subquery (SELECT ...)
  503. if p.curTokenIs(lexer.TokenLParen) {
  504. p.nextToken()
  505. if p.curTokenIs(lexer.TokenSELECT) {
  506. subquery, err := p.parseSelect()
  507. if err != nil {
  508. return nil, err
  509. }
  510. ref.Subquery = subquery
  511. if !p.curTokenIs(lexer.TokenRParen) {
  512. return nil, p.curError("expected ) after subquery")
  513. }
  514. p.nextToken()
  515. // Subquery must have an alias
  516. if p.curTokenIs(lexer.TokenAS) {
  517. p.nextToken()
  518. }
  519. if !p.curTokenIs(lexer.TokenIdent) {
  520. return nil, p.curError("subquery in FROM must have an alias")
  521. }
  522. ref.Alias = p.curToken.Literal
  523. p.nextToken()
  524. return ref, nil
  525. }
  526. // Parenthesized table expression: (table1 JOIN table2) or (table1, table2)
  527. innerRefs, err := p.parseTableRefs()
  528. if err != nil {
  529. return nil, err
  530. }
  531. if !p.curTokenIs(lexer.TokenRParen) {
  532. return nil, p.curError("expected ) after table expression")
  533. }
  534. p.nextToken()
  535. // Flatten: use first ref as base, attach remaining as joins
  536. if len(innerRefs) == 0 {
  537. return nil, p.curError("empty table expression")
  538. }
  539. base := &innerRefs[0]
  540. for i := 1; i < len(innerRefs); i++ {
  541. cur := base
  542. for cur.Join != nil && cur.Join.Table != nil {
  543. cur = cur.Join.Table
  544. }
  545. extra := innerRefs[i]
  546. if cur.Join == nil {
  547. cur.Join = &JoinClause{Type: JoinCross, Table: &extra}
  548. } else {
  549. cur.Join.Table = &extra
  550. }
  551. }
  552. return base, nil
  553. }
  554. if !p.curTokenIs(lexer.TokenIdent) {
  555. return nil, p.curError("expected table name")
  556. }
  557. ref.Name = p.curToken.Literal
  558. p.nextToken()
  559. // Table function in FROM. unnest(array) and the jsonb set-returning
  560. // functions are the only recognized forms; other function names in FROM are
  561. // reported as an unsupported table function.
  562. if allowFunction && p.curTokenIs(lexer.TokenLParen) {
  563. if !isTableFunctionName(ref.Name) {
  564. return nil, pgerror.Unsupported("table function %s() is not supported; FROM accepts unnest(array), jsonb_each(jsonb), jsonb_each_text(jsonb), jsonb_array_elements(jsonb), jsonb_array_elements_text(jsonb), and jsonb_object_keys(jsonb)", ref.Name)
  565. }
  566. call, err := p.parseFunctionCall(ref.Name)
  567. if err != nil {
  568. return nil, err
  569. }
  570. fn, ok := call.(*FunctionCall)
  571. if !ok {
  572. return nil, p.curError("invalid table function")
  573. }
  574. ref.Function = fn
  575. if p.curTokenIs(lexer.TokenAS) {
  576. p.nextToken()
  577. }
  578. if p.curTokenIs(lexer.TokenIdent) && !p.isClauseKeyword() {
  579. ref.Alias = p.curToken.Literal
  580. p.nextToken()
  581. if p.curTokenIs(lexer.TokenLParen) {
  582. aliases, err := p.parseColumnAliasList()
  583. if err != nil {
  584. return nil, err
  585. }
  586. ref.ColumnAliases = aliases
  587. }
  588. }
  589. return ref, nil
  590. }
  591. // Check for schema.table
  592. if p.curTokenIs(lexer.TokenDot) {
  593. p.nextToken()
  594. if !p.curTokenIs(lexer.TokenIdent) {
  595. return nil, p.curError("expected table name after dot")
  596. }
  597. ref.Schema = ref.Name
  598. ref.Name = p.curToken.Literal
  599. p.nextToken()
  600. }
  601. // Check for alias
  602. if p.curTokenIs(lexer.TokenAS) {
  603. p.nextToken()
  604. if !p.curTokenIs(lexer.TokenIdent) {
  605. return nil, p.curError("expected identifier after AS")
  606. }
  607. ref.Alias = p.curToken.Literal
  608. p.nextToken()
  609. } else if p.curTokenIs(lexer.TokenIdent) && !p.isClauseKeyword() && !p.isLockingClauseStart() {
  610. ref.Alias = p.curToken.Literal
  611. p.nextToken()
  612. }
  613. return ref, nil
  614. }
  615. // parseColumnAliasList parses the parenthesized column alias list of a table
  616. // function: `AS t(a, b)`. The caller has already consumed the alias.
  617. func (p *Parser) parseColumnAliasList() ([]string, error) {
  618. if !p.curTokenIs(lexer.TokenLParen) {
  619. return nil, p.curError("expected ( before column aliases")
  620. }
  621. p.nextToken()
  622. var aliases []string
  623. for {
  624. if !p.curTokenIs(lexer.TokenIdent) {
  625. return nil, p.curError("expected a column alias")
  626. }
  627. aliases = append(aliases, p.curToken.Literal)
  628. p.nextToken()
  629. if !p.curTokenIs(lexer.TokenComma) {
  630. break
  631. }
  632. p.nextToken()
  633. }
  634. if !p.curTokenIs(lexer.TokenRParen) {
  635. return nil, p.curError("expected ) after column aliases")
  636. }
  637. p.nextToken()
  638. return aliases, nil
  639. }
  640. func (p *Parser) isJoinKeyword() bool {
  641. switch p.curToken.Type {
  642. case lexer.TokenJOIN, lexer.TokenINNER, lexer.TokenLEFT,
  643. lexer.TokenRIGHT, lexer.TokenFULL, lexer.TokenCROSS,
  644. lexer.TokenNATURAL:
  645. return true
  646. }
  647. return false
  648. }
  649. func (p *Parser) isClauseKeyword() bool {
  650. switch p.curToken.Type {
  651. case lexer.TokenWHERE, lexer.TokenGROUP, lexer.TokenHAVING,
  652. lexer.TokenORDER, lexer.TokenLIMIT, lexer.TokenOFFSET,
  653. lexer.TokenUNION, lexer.TokenINTERSECT, lexer.TokenEXCEPT,
  654. lexer.TokenON, lexer.TokenUSING:
  655. return true
  656. }
  657. return false
  658. }
  659. // isLockingClauseStart reports whether the current identifier starts a
  660. // PostgreSQL row-locking clause. FOR is not a reserved keyword in this lexer,
  661. // so without this guard "FROM t FOR UPDATE" would treat FOR as a table alias.
  662. func (p *Parser) isLockingClauseStart() bool {
  663. return p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "FOR")
  664. }
  665. // parseLockingClause parses SELECT ... FOR UPDATE/SHARE [NOWAIT | SKIP LOCKED].
  666. // FOR is not a reserved keyword in this lexer, so the caller already used
  667. // isLockingClauseStart to avoid treating it as a table alias.
  668. func (p *Parser) parseLockingClause() (*LockingClause, error) {
  669. if !p.isLockingClauseStart() {
  670. return nil, nil
  671. }
  672. p.nextToken() // consume FOR
  673. clause := &LockingClause{Strength: LockUpdate}
  674. switch {
  675. case p.curTokenIs(lexer.TokenUPDATE):
  676. p.nextToken()
  677. case p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "SHARE"):
  678. clause.Strength = LockShare
  679. p.nextToken()
  680. case p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "NO"):
  681. return nil, pgerror.Unsupported("FOR NO KEY UPDATE is not supported; use FOR UPDATE")
  682. case p.curTokenIs(lexer.TokenKEY):
  683. return nil, pgerror.Unsupported("FOR KEY SHARE is not supported; use FOR SHARE")
  684. default:
  685. return nil, p.curError("expected UPDATE or SHARE after FOR")
  686. }
  687. if p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "OF") {
  688. return nil, pgerror.Unsupported("SELECT ... FOR UPDATE OF table is not supported")
  689. }
  690. if p.curTokenIs(lexer.TokenIdent) {
  691. switch {
  692. case strings.EqualFold(p.curToken.Literal, "NOWAIT"):
  693. clause.Wait = LockWaitNoWait
  694. p.nextToken()
  695. case strings.EqualFold(p.curToken.Literal, "SKIP"):
  696. p.nextToken()
  697. if !p.curTokenIs(lexer.TokenIdent) || !strings.EqualFold(p.curToken.Literal, "LOCKED") {
  698. return nil, p.curError("expected LOCKED after SKIP")
  699. }
  700. clause.Wait = LockWaitSkipLocked
  701. p.nextToken()
  702. }
  703. }
  704. return clause, nil
  705. }
  706. func (p *Parser) parseJoin() (*JoinClause, error) {
  707. join := &JoinClause{Type: JoinInner}
  708. // Determine join type
  709. switch p.curToken.Type {
  710. case lexer.TokenINNER:
  711. join.Type = JoinInner
  712. p.nextToken()
  713. case lexer.TokenLEFT:
  714. join.Type = JoinLeft
  715. p.nextToken()
  716. if p.curTokenIs(lexer.TokenOUTER) {
  717. p.nextToken()
  718. }
  719. case lexer.TokenRIGHT:
  720. join.Type = JoinRight
  721. p.nextToken()
  722. if p.curTokenIs(lexer.TokenOUTER) {
  723. p.nextToken()
  724. }
  725. case lexer.TokenFULL:
  726. join.Type = JoinFull
  727. p.nextToken()
  728. if p.curTokenIs(lexer.TokenOUTER) {
  729. p.nextToken()
  730. }
  731. case lexer.TokenCROSS:
  732. join.Type = JoinCross
  733. p.nextToken()
  734. case lexer.TokenNATURAL:
  735. p.nextToken()
  736. // Could be NATURAL LEFT/RIGHT/INNER JOIN
  737. if p.curTokenIs(lexer.TokenLEFT) {
  738. join.Type = JoinLeft
  739. p.nextToken()
  740. } else if p.curTokenIs(lexer.TokenRIGHT) {
  741. join.Type = JoinRight
  742. p.nextToken()
  743. }
  744. }
  745. // Expect JOIN keyword
  746. if p.curTokenIs(lexer.TokenJOIN) {
  747. p.nextToken()
  748. } else if p.curToken.Type != lexer.TokenIdent {
  749. return nil, p.curError("expected JOIN")
  750. }
  751. // Parse table reference
  752. table, err := p.parseTableRef(true)
  753. if err != nil {
  754. return nil, err
  755. }
  756. join.Table = table
  757. // Parse ON or USING clause
  758. if p.curTokenIs(lexer.TokenON) {
  759. p.nextToken()
  760. cond, err := p.parseExpr()
  761. if err != nil {
  762. return nil, err
  763. }
  764. join.Condition = cond
  765. } else if p.curTokenIs(lexer.TokenUSING) {
  766. p.nextToken()
  767. if !p.curTokenIs(lexer.TokenLParen) {
  768. return nil, p.curError("expected (")
  769. }
  770. p.nextToken()
  771. cols, err := p.parseIdentList()
  772. if err != nil {
  773. return nil, err
  774. }
  775. join.Using = cols
  776. if !p.curTokenIs(lexer.TokenRParen) {
  777. return nil, p.curError("expected )")
  778. }
  779. p.nextToken()
  780. }
  781. return join, nil
  782. }
  783. func (p *Parser) parseOrderBy() ([]OrderByItem, error) {
  784. var items []OrderByItem
  785. for {
  786. item := OrderByItem{}
  787. expr, err := p.parseExpr()
  788. if err != nil {
  789. return nil, err
  790. }
  791. item.Expr = expr
  792. if p.curTokenIs(lexer.TokenDESC) {
  793. item.Desc = true
  794. p.nextToken()
  795. } else if p.curTokenIs(lexer.TokenASC) {
  796. p.nextToken()
  797. }
  798. // Optional NULLS FIRST / NULLS LAST.
  799. if p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "NULLS") {
  800. p.nextToken()
  801. if !p.curTokenIs(lexer.TokenIdent) {
  802. return nil, p.curError("expected FIRST or LAST after NULLS")
  803. }
  804. switch {
  805. case strings.EqualFold(p.curToken.Literal, "FIRST"):
  806. item.NullsOrder = NullsFirst
  807. case strings.EqualFold(p.curToken.Literal, "LAST"):
  808. item.NullsOrder = NullsLast
  809. default:
  810. return nil, p.curError("expected FIRST or LAST after NULLS")
  811. }
  812. p.nextToken()
  813. }
  814. items = append(items, item)
  815. if !p.curTokenIs(lexer.TokenComma) {
  816. break
  817. }
  818. p.nextToken()
  819. }
  820. return items, nil
  821. }
  822. // parseInsert parses an INSERT statement.
  823. func (p *Parser) parseInsert() (*InsertStmt, error) {
  824. stmt := &InsertStmt{}
  825. p.nextToken() // consume INSERT
  826. // Check for OR conflict clause
  827. if p.curTokenIs(lexer.TokenOR) {
  828. p.nextToken()
  829. switch p.curToken.Type {
  830. case lexer.TokenREPLACE:
  831. stmt.OnConflict = ConflictReplace
  832. case lexer.TokenIGNORE:
  833. stmt.OnConflict = ConflictIgnore
  834. case lexer.TokenFAIL:
  835. stmt.OnConflict = ConflictFail
  836. case lexer.TokenABORT:
  837. stmt.OnConflict = ConflictAbort
  838. case lexer.TokenROLLBACK:
  839. stmt.OnConflict = ConflictRollback
  840. default:
  841. return nil, p.curError("expected REPLACE, IGNORE, FAIL, ABORT, or ROLLBACK after OR")
  842. }
  843. p.nextToken()
  844. }
  845. if !p.curTokenIs(lexer.TokenINTO) {
  846. return nil, p.curError("expected INTO")
  847. }
  848. p.nextToken()
  849. // Parse table name
  850. table, err := p.parseTableRef(false)
  851. if err != nil {
  852. return nil, err
  853. }
  854. stmt.Table = table
  855. // Parse optional column list
  856. if p.curTokenIs(lexer.TokenLParen) {
  857. p.nextToken()
  858. cols, err := p.parseIdentList()
  859. if err != nil {
  860. return nil, err
  861. }
  862. stmt.Columns = cols
  863. if !p.curTokenIs(lexer.TokenRParen) {
  864. return nil, p.curError("expected )")
  865. }
  866. p.nextToken()
  867. }
  868. // Parse VALUES, SELECT, or SQLite's INSERT ... WITH ... SELECT form.
  869. if p.curTokenIs(lexer.TokenVALUES) {
  870. p.nextToken()
  871. values, err := p.parseValuesList()
  872. if err != nil {
  873. return nil, err
  874. }
  875. stmt.Values = values
  876. } else if p.curTokenIs(lexer.TokenDEFAULT) {
  877. // INSERT ... DEFAULT VALUES supplies no values; one row is built from
  878. // the schema defaults.
  879. p.nextToken()
  880. if !p.curTokenIs(lexer.TokenVALUES) {
  881. return nil, p.curError("expected VALUES after DEFAULT")
  882. }
  883. p.nextToken()
  884. stmt.DefaultValues = true
  885. stmt.Values = [][]Expr{{}}
  886. } else if p.curTokenIs(lexer.TokenSELECT) {
  887. sel, err := p.parseSelect()
  888. if err != nil {
  889. return nil, err
  890. }
  891. stmt.Select = sel
  892. } else if p.isWithStart() {
  893. withStmt, err := p.parseWithStatement()
  894. if err != nil {
  895. return nil, err
  896. }
  897. sel, ok := withStmt.(*SelectStmt)
  898. if !ok {
  899. return nil, p.curError("expected SELECT after WITH")
  900. }
  901. stmt.Select = sel
  902. } else {
  903. return nil, p.curError("expected VALUES, SELECT, WITH, or DEFAULT VALUES")
  904. }
  905. if p.curTokenIs(lexer.TokenON) {
  906. p.nextToken()
  907. if !p.curTokenIs(lexer.TokenCONFLICT) {
  908. return nil, p.curError("expected CONFLICT after ON")
  909. }
  910. p.nextToken()
  911. if p.curTokenIs(lexer.TokenLParen) {
  912. p.nextToken()
  913. target, err := p.parseIdentList()
  914. if err != nil {
  915. return nil, err
  916. }
  917. stmt.ConflictTarget = target
  918. if !p.curTokenIs(lexer.TokenRParen) {
  919. return nil, p.curError("expected )")
  920. }
  921. p.nextToken()
  922. }
  923. if !p.curTokenIs(lexer.TokenDO) {
  924. return nil, p.curError("expected DO after ON CONFLICT")
  925. }
  926. p.nextToken()
  927. if p.curTokenIs(lexer.TokenNOTHING) {
  928. stmt.ConflictDoNothing = true
  929. p.nextToken()
  930. } else if p.curTokenIs(lexer.TokenUPDATE) {
  931. p.nextToken()
  932. if !p.curTokenIs(lexer.TokenSET) {
  933. return nil, p.curError("expected SET after DO UPDATE")
  934. }
  935. p.nextToken()
  936. for {
  937. if !p.curTokenIs(lexer.TokenIdent) {
  938. return nil, p.curError("expected column name")
  939. }
  940. column := p.curToken.Literal
  941. p.nextToken()
  942. if !p.curTokenIs(lexer.TokenEq) {
  943. return nil, p.curError("expected =")
  944. }
  945. p.nextToken()
  946. value, err := p.parseExpr()
  947. if err != nil {
  948. return nil, err
  949. }
  950. stmt.ConflictUpdate = append(stmt.ConflictUpdate, Assignment{Column: column, Value: value})
  951. if !p.curTokenIs(lexer.TokenComma) {
  952. break
  953. }
  954. p.nextToken()
  955. }
  956. } else {
  957. return nil, p.curError("expected NOTHING or UPDATE after DO")
  958. }
  959. }
  960. if p.curTokenIs(lexer.TokenRETURNING) {
  961. returning, err := p.parseReturningClause()
  962. if err != nil {
  963. return nil, err
  964. }
  965. stmt.Returning = returning
  966. }
  967. return stmt, nil
  968. }
  969. func (p *Parser) parseValuesList() ([][]Expr, error) {
  970. var rows [][]Expr
  971. for {
  972. if !p.curTokenIs(lexer.TokenLParen) {
  973. return nil, p.curError("expected (")
  974. }
  975. p.nextToken()
  976. row, err := p.parseExprList()
  977. if err != nil {
  978. return nil, err
  979. }
  980. rows = append(rows, row)
  981. if !p.curTokenIs(lexer.TokenRParen) {
  982. return nil, p.curError("expected )")
  983. }
  984. p.nextToken()
  985. if !p.curTokenIs(lexer.TokenComma) {
  986. break
  987. }
  988. p.nextToken()
  989. }
  990. return rows, nil
  991. }
  992. // parseUpdate parses an UPDATE statement.
  993. func (p *Parser) parseUpdate() (*UpdateStmt, error) {
  994. stmt := &UpdateStmt{}
  995. p.nextToken() // consume UPDATE
  996. // Parse table name
  997. table, err := p.parseTableRef(false)
  998. if err != nil {
  999. return nil, err
  1000. }
  1001. stmt.Table = table
  1002. // Expect SET
  1003. if !p.curTokenIs(lexer.TokenSET) {
  1004. return nil, p.curError("expected SET")
  1005. }
  1006. p.nextToken()
  1007. // Parse assignments
  1008. for {
  1009. if !p.curTokenIs(lexer.TokenIdent) {
  1010. return nil, p.curError("expected column name")
  1011. }
  1012. col := p.curToken.Literal
  1013. p.nextToken()
  1014. if !p.curTokenIs(lexer.TokenEq) {
  1015. return nil, p.curError("expected =")
  1016. }
  1017. p.nextToken()
  1018. val, err := p.parseExpr()
  1019. if err != nil {
  1020. return nil, err
  1021. }
  1022. stmt.Set = append(stmt.Set, Assignment{Column: col, Value: val})
  1023. if !p.curTokenIs(lexer.TokenComma) {
  1024. break
  1025. }
  1026. p.nextToken()
  1027. }
  1028. // Parse optional FROM clause (SQLite UPDATE ... FROM).
  1029. if p.curTokenIs(lexer.TokenFROM) {
  1030. p.nextToken()
  1031. from, err := p.parseTableRefs()
  1032. if err != nil {
  1033. return nil, err
  1034. }
  1035. stmt.From = from
  1036. }
  1037. // Parse optional WHERE
  1038. if p.curTokenIs(lexer.TokenWHERE) {
  1039. p.nextToken()
  1040. where, err := p.parseExpr()
  1041. if err != nil {
  1042. return nil, err
  1043. }
  1044. stmt.Where = where
  1045. }
  1046. if p.curTokenIs(lexer.TokenRETURNING) {
  1047. returning, err := p.parseReturningClause()
  1048. if err != nil {
  1049. return nil, err
  1050. }
  1051. stmt.Returning = returning
  1052. }
  1053. return stmt, nil
  1054. }
  1055. // parseDelete parses a DELETE statement.
  1056. func (p *Parser) parseDelete() (*DeleteStmt, error) {
  1057. stmt := &DeleteStmt{}
  1058. p.nextToken() // consume DELETE
  1059. if !p.curTokenIs(lexer.TokenFROM) {
  1060. return nil, p.curError("expected FROM")
  1061. }
  1062. p.nextToken()
  1063. // Parse table name
  1064. table, err := p.parseTableRef(false)
  1065. if err != nil {
  1066. return nil, err
  1067. }
  1068. stmt.Table = table
  1069. // Parse optional WHERE
  1070. if p.curTokenIs(lexer.TokenWHERE) {
  1071. p.nextToken()
  1072. where, err := p.parseExpr()
  1073. if err != nil {
  1074. return nil, err
  1075. }
  1076. stmt.Where = where
  1077. }
  1078. if p.curTokenIs(lexer.TokenRETURNING) {
  1079. returning, err := p.parseReturningClause()
  1080. if err != nil {
  1081. return nil, err
  1082. }
  1083. stmt.Returning = returning
  1084. }
  1085. return stmt, nil
  1086. }
  1087. // parseReturningClause parses the projection after a RETURNING keyword. The
  1088. // caller must leave curToken on the RETURNING identifier.
  1089. func (p *Parser) parseReturningClause() ([]SelectColumn, error) {
  1090. p.nextToken() // consume RETURNING
  1091. cols, err := p.parseSelectColumns()
  1092. if err != nil {
  1093. return nil, err
  1094. }
  1095. if len(cols) == 0 {
  1096. return nil, p.curError("RETURNING requires at least one expression")
  1097. }
  1098. return cols, nil
  1099. }
  1100. // parseCreate parses CREATE statements.
  1101. func (p *Parser) parseCreate() (Statement, error) {
  1102. p.nextToken() // consume CREATE
  1103. switch p.curToken.Type {
  1104. case lexer.TokenTABLE:
  1105. return p.parseCreateTable()
  1106. case lexer.TokenINDEX:
  1107. return p.parseCreateIndex(false)
  1108. case lexer.TokenUNIQUE:
  1109. p.nextToken() // consume UNIQUE
  1110. if !p.curTokenIs(lexer.TokenINDEX) {
  1111. return nil, p.curError("expected INDEX after UNIQUE")
  1112. }
  1113. return p.parseCreateIndex(true)
  1114. case lexer.TokenVIEW:
  1115. return p.parseCreateView()
  1116. default:
  1117. return nil, p.curError("expected TABLE or INDEX after CREATE")
  1118. }
  1119. }
  1120. func (p *Parser) parseCreateTable() (*CreateTableStmt, error) {
  1121. stmt := &CreateTableStmt{}
  1122. p.nextToken() // consume TABLE
  1123. // Check for IF NOT EXISTS
  1124. if p.curTokenIs(lexer.TokenIF) {
  1125. p.nextToken()
  1126. if !p.curTokenIs(lexer.TokenNOT) {
  1127. return nil, p.curError("expected NOT")
  1128. }
  1129. p.nextToken()
  1130. if !p.curTokenIs(lexer.TokenEXISTS) {
  1131. return nil, p.curError("expected EXISTS")
  1132. }
  1133. stmt.IfNotExists = true
  1134. p.nextToken()
  1135. }
  1136. // Parse table name
  1137. table, err := p.parseTableRef(false)
  1138. if err != nil {
  1139. return nil, err
  1140. }
  1141. stmt.Table = table
  1142. // Expect (
  1143. if !p.curTokenIs(lexer.TokenLParen) {
  1144. return nil, p.curError("expected (")
  1145. }
  1146. p.nextToken()
  1147. // Parse column definitions and constraints
  1148. for {
  1149. if p.curTokenIs(lexer.TokenRParen) {
  1150. break
  1151. }
  1152. // Check for table constraint
  1153. if p.isTableConstraintStart() {
  1154. constraint, err := p.parseTableConstraint()
  1155. if err != nil {
  1156. return nil, err
  1157. }
  1158. stmt.Constraints = append(stmt.Constraints, *constraint)
  1159. } else {
  1160. // Column definition
  1161. col, err := p.parseColumnDef()
  1162. if err != nil {
  1163. return nil, err
  1164. }
  1165. stmt.Columns = append(stmt.Columns, *col)
  1166. }
  1167. if !p.curTokenIs(lexer.TokenComma) {
  1168. break
  1169. }
  1170. p.nextToken()
  1171. }
  1172. if !p.curTokenIs(lexer.TokenRParen) {
  1173. return nil, p.curError("expected )")
  1174. }
  1175. p.nextToken()
  1176. return stmt, nil
  1177. }
  1178. func (p *Parser) isTableConstraintStart() bool {
  1179. switch p.curToken.Type {
  1180. case lexer.TokenPRIMARY, lexer.TokenFOREIGN, lexer.TokenUNIQUE,
  1181. lexer.TokenCHECK, lexer.TokenCONSTRAINT:
  1182. return true
  1183. }
  1184. return false
  1185. }
  1186. func (p *Parser) parseColumnDef() (*ColumnDef, error) {
  1187. col := &ColumnDef{}
  1188. if !p.curIsName() {
  1189. return nil, p.curError("expected column name")
  1190. }
  1191. col.Name = p.curToken.Literal
  1192. p.nextToken()
  1193. // Parse data type
  1194. dataType, err := p.parseDataType()
  1195. if err != nil {
  1196. return nil, err
  1197. }
  1198. col.Type = *dataType
  1199. // Parse column constraints
  1200. for {
  1201. if consumed, err := p.tryParseGeneratedColumn(col); err != nil {
  1202. return nil, err
  1203. } else if consumed {
  1204. continue
  1205. }
  1206. constraint, ok, err := p.parseColumnConstraint()
  1207. if err != nil {
  1208. return nil, err
  1209. }
  1210. if !ok {
  1211. break
  1212. }
  1213. if constraint != nil {
  1214. col.Constraints = append(col.Constraints, *constraint)
  1215. }
  1216. }
  1217. return col, nil
  1218. }
  1219. // tryParseGeneratedColumn parses a GENERATED ALWAYS AS (expr) [STORED|VIRTUAL]
  1220. // clause, or the shorthand AS (expr) [STORED|VIRTUAL]. It reports whether a
  1221. // clause was consumed. Generated columns cannot be written by the user.
  1222. func (p *Parser) tryParseGeneratedColumn(col *ColumnDef) (bool, error) {
  1223. started := false
  1224. if p.curIdentIs("GENERATED") {
  1225. started = true
  1226. p.nextToken()
  1227. if !p.curIdentIs("ALWAYS") {
  1228. return false, p.curError("expected ALWAYS after GENERATED")
  1229. }
  1230. p.nextToken()
  1231. }
  1232. if !p.curTokenIs(lexer.TokenAS) {
  1233. if started {
  1234. return false, p.curError("expected AS in generated column definition")
  1235. }
  1236. return false, nil
  1237. }
  1238. p.nextToken() // consume AS
  1239. if !p.curTokenIs(lexer.TokenLParen) {
  1240. return false, p.curError("expected ( after AS")
  1241. }
  1242. p.nextToken()
  1243. expr, err := p.parseExpr()
  1244. if err != nil {
  1245. return false, err
  1246. }
  1247. if !p.curTokenIs(lexer.TokenRParen) {
  1248. return false, p.curError("expected ) after generated expression")
  1249. }
  1250. p.nextToken()
  1251. col.GeneratedExpr = expr
  1252. if p.curIdentIs("STORED") {
  1253. col.GeneratedStored = true
  1254. p.nextToken()
  1255. } else if p.curIdentIs("VIRTUAL") {
  1256. col.GeneratedStored = false
  1257. p.nextToken()
  1258. }
  1259. return true, nil
  1260. }
  1261. // identTypeAliases maps non-reserved type names (lexed as plain identifiers)
  1262. // to their canonical data type name. These are stored with SQLite text
  1263. // affinity and never gain native PostgreSQL semantics.
  1264. var identTypeAliases = map[string]string{
  1265. "UUID": "UUID",
  1266. "OID": "OID",
  1267. "REGCLASS": "REGCLASS",
  1268. "REGTYPE": "REGTYPE",
  1269. "NAME": "NAME",
  1270. }
  1271. func (p *Parser) parseDataType() (*DataType, error) {
  1272. dt := &DataType{}
  1273. if p.curTokenIs(lexer.TokenIdent) {
  1274. // A few well-known type names (e.g. UUID) are not reserved keywords and
  1275. // lex as identifiers. Recognize them as type aliases so they can be used
  1276. // in column definitions.
  1277. name, ok := identTypeAliases[strings.ToUpper(p.curToken.Literal)]
  1278. if !ok {
  1279. return nil, p.curError("expected data type")
  1280. }
  1281. dt.Name = name
  1282. p.nextToken()
  1283. } else {
  1284. if !p.isDataTypeKeyword() {
  1285. return nil, p.curError("expected data type")
  1286. }
  1287. dt.Name = strings.ToUpper(p.curToken.Literal)
  1288. p.nextToken()
  1289. }
  1290. // DOUBLE PRECISION is the PostgreSQL spelling of the DOUBLE type. PRECISION
  1291. // is not a reserved word, so consume it as a trailing type qualifier.
  1292. if dt.Name == "DOUBLE" && p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "PRECISION") {
  1293. p.nextToken()
  1294. }
  1295. // Check for precision/scale
  1296. if p.curTokenIs(lexer.TokenLParen) {
  1297. p.nextToken()
  1298. if !p.curTokenIs(lexer.TokenNumber) {
  1299. return nil, p.curError("expected number for precision")
  1300. }
  1301. // Parse precision (simplified - just store in Precision)
  1302. dt.Precision = parseInt(p.curToken.Literal)
  1303. p.nextToken()
  1304. if p.curTokenIs(lexer.TokenComma) {
  1305. p.nextToken()
  1306. if !p.curTokenIs(lexer.TokenNumber) {
  1307. return nil, p.curError("expected number for scale")
  1308. }
  1309. dt.Scale = parseInt(p.curToken.Literal)
  1310. p.nextToken()
  1311. }
  1312. if !p.curTokenIs(lexer.TokenRParen) {
  1313. return nil, p.curError("expected )")
  1314. }
  1315. p.nextToken()
  1316. }
  1317. // A single trailing [] declares a one-dimensional array. Only element types
  1318. // the engine can encode are accepted.
  1319. if p.curTokenIs(lexer.TokenLBracket) {
  1320. if !p.peekTokenIs(lexer.TokenRBracket) {
  1321. return nil, p.curError("expected ] after [ in array type")
  1322. }
  1323. p.nextToken() // [
  1324. p.nextToken() // ]
  1325. if p.curTokenIs(lexer.TokenLBracket) {
  1326. return nil, pgerror.Unsupported("multidimensional arrays are not supported; declare a single trailing []")
  1327. }
  1328. if !isSupportedArrayElementType(dt.Name) {
  1329. return nil, pgerror.Unsupported("arrays of %s are not supported; supported element types are TEXT, VARCHAR, INTEGER, BIGINT, SMALLINT, BOOLEAN, REAL, DOUBLE PRECISION, and NUMERIC", dt.Name)
  1330. }
  1331. dt.Array = true
  1332. }
  1333. return dt, nil
  1334. }
  1335. // isTableFunctionName reports whether name is a set-returning function the
  1336. // executor can materialize as the single FROM item.
  1337. func isTableFunctionName(name string) bool {
  1338. switch strings.ToLower(name) {
  1339. case "unnest", "jsonb_each", "jsonb_each_text", "jsonb_array_elements",
  1340. "jsonb_array_elements_text", "jsonb_object_keys":
  1341. return true
  1342. default:
  1343. return false
  1344. }
  1345. }
  1346. // isSupportedArrayElementType reports whether an element type name can be
  1347. // encoded as an array element. The list mirrors the element types the executor
  1348. // canonicalizes and the pgserver advertises array OIDs for.
  1349. func isSupportedArrayElementType(name string) bool {
  1350. switch strings.ToUpper(name) {
  1351. case "TEXT", "VARCHAR", "CHAR", "CHARACTER", "CLOB", "NCHAR", "NVARCHAR",
  1352. "INTEGER", "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT",
  1353. "BOOLEAN", "BOOL",
  1354. "REAL", "FLOAT", "DOUBLE", "NUMERIC", "DECIMAL":
  1355. return true
  1356. default:
  1357. return false
  1358. }
  1359. }
  1360. func (p *Parser) isDataTypeKeyword() bool {
  1361. switch p.curToken.Type {
  1362. case lexer.TokenINTEGER, lexer.TokenINT, lexer.TokenTINYINT, lexer.TokenSMALLINT, lexer.TokenMEDIUMINT, lexer.TokenBIGINT,
  1363. lexer.TokenREAL, lexer.TokenFLOAT, lexer.TokenDOUBLE,
  1364. lexer.TokenNUMERIC, lexer.TokenDECIMAL,
  1365. lexer.TokenTEXT, lexer.TokenVARCHAR, lexer.TokenCHAR, lexer.TokenCHARACTER, lexer.TokenCLOB, lexer.TokenNCHAR, lexer.TokenNVARCHAR,
  1366. lexer.TokenBLOB, lexer.TokenBOOLEAN,
  1367. lexer.TokenDATE, lexer.TokenTIME, lexer.TokenTIMESTAMP, lexer.TokenDATETIME, lexer.TokenJSON, lexer.TokenJSONB:
  1368. return true
  1369. }
  1370. return false
  1371. }
  1372. func (p *Parser) parseColumnConstraint() (*ColumnConstraint, bool, error) {
  1373. constraint := &ColumnConstraint{}
  1374. // A column-level constraint can be named: `col TYPE CONSTRAINT name CHECK
  1375. // (...)` is the same constraint as the unnamed form.
  1376. named := false
  1377. if p.curTokenIs(lexer.TokenCONSTRAINT) {
  1378. p.nextToken()
  1379. if !p.curTokenIs(lexer.TokenIdent) {
  1380. return nil, false, p.curError("expected constraint name")
  1381. }
  1382. constraint.Name = p.curToken.Literal
  1383. named = true
  1384. p.nextToken()
  1385. }
  1386. switch p.curToken.Type {
  1387. case lexer.TokenPRIMARY:
  1388. p.nextToken()
  1389. if !p.curTokenIs(lexer.TokenKEY) {
  1390. return nil, false, p.curError("expected KEY after PRIMARY")
  1391. }
  1392. constraint.Type = ConstraintPrimaryKey
  1393. p.nextToken()
  1394. if action, ok, err := p.parseOnConflictAction(); err != nil {
  1395. return nil, false, err
  1396. } else if ok {
  1397. constraint.OnConflict = action
  1398. constraint.HasOnConflict = true
  1399. }
  1400. case lexer.TokenNOT:
  1401. p.nextToken()
  1402. if !p.curTokenIs(lexer.TokenNULL) {
  1403. return nil, false, p.curError("expected NULL after NOT")
  1404. }
  1405. constraint.Type = ConstraintNotNull
  1406. p.nextToken()
  1407. case lexer.TokenUNIQUE:
  1408. constraint.Type = ConstraintUnique
  1409. p.nextToken()
  1410. if action, ok, err := p.parseOnConflictAction(); err != nil {
  1411. return nil, false, err
  1412. } else if ok {
  1413. constraint.OnConflict = action
  1414. constraint.HasOnConflict = true
  1415. }
  1416. case lexer.TokenDEFAULT:
  1417. p.nextToken()
  1418. // parseUnaryExpr accepts a signed numeric literal (-1, +5) and falls
  1419. // through to primary expressions, including parenthesized expressions.
  1420. // It stops before NOT/NULL, so a following NOT NULL constraint is left
  1421. // for the enclosing constraint loop.
  1422. expr, err := p.parseUnaryExpr()
  1423. if err != nil {
  1424. return nil, false, err
  1425. }
  1426. constraint.Type = ConstraintDefault
  1427. constraint.Default = expr
  1428. case lexer.TokenREFERENCES:
  1429. p.nextToken()
  1430. if !p.curTokenIs(lexer.TokenIdent) {
  1431. return nil, false, p.curError("expected table name after REFERENCES")
  1432. }
  1433. constraint.Type = ConstraintForeignKey
  1434. constraint.RefTable = p.curToken.Literal
  1435. p.nextToken()
  1436. if p.curTokenIs(lexer.TokenLParen) {
  1437. refCols, err := p.parseParenIdentList()
  1438. if err != nil {
  1439. return nil, false, err
  1440. }
  1441. constraint.RefColumns = refCols
  1442. }
  1443. if err := p.parseForeignKeyClauses(&constraint.OnDelete, &constraint.OnUpdate, &constraint.Deferrable); err != nil {
  1444. return nil, false, err
  1445. }
  1446. case lexer.TokenAUTOINCREMENT:
  1447. constraint.Type = ConstraintAutoIncrement
  1448. p.nextToken()
  1449. case lexer.TokenCHECK:
  1450. p.nextToken()
  1451. if !p.curTokenIs(lexer.TokenLParen) {
  1452. return nil, false, p.curError("expected ( after CHECK")
  1453. }
  1454. p.nextToken()
  1455. check, err := p.parseExpr()
  1456. if err != nil {
  1457. return nil, false, err
  1458. }
  1459. if !p.curTokenIs(lexer.TokenRParen) {
  1460. return nil, false, p.curError("expected ) after CHECK expression")
  1461. }
  1462. p.nextToken()
  1463. constraint.Type = ConstraintCheck
  1464. constraint.Check = check
  1465. case lexer.TokenNULL:
  1466. // Explicit NULL is a no-op: columns are nullable by default, so an
  1467. // explicit NULL declaration carries no constraint. Consume it so
  1468. // "col TYPE NULL" parses without inventing a fake nullable constraint.
  1469. // NOT NULL is applied whenever it appears, regardless of ordering.
  1470. if named {
  1471. return nil, false, p.curError("expected constraint type after constraint name")
  1472. }
  1473. p.nextToken()
  1474. return nil, true, nil
  1475. default:
  1476. if named {
  1477. return nil, false, p.curError("expected constraint type after constraint name")
  1478. }
  1479. return nil, false, nil
  1480. }
  1481. return constraint, true, nil
  1482. }
  1483. // parseOnConflictAction parses an optional constraint clause of the form
  1484. // ON CONFLICT IGNORE|REPLACE|FAIL|ABORT|ROLLBACK. It reports ok=false and leaves
  1485. // the cursor unchanged when no ON CONFLICT follows.
  1486. func (p *Parser) parseOnConflictAction() (ConflictAction, bool, error) {
  1487. if !p.curTokenIs(lexer.TokenON) {
  1488. return ConflictAbort, false, nil
  1489. }
  1490. p.nextToken()
  1491. if !p.curTokenIs(lexer.TokenCONFLICT) {
  1492. return ConflictAbort, false, p.curError("expected CONFLICT after ON")
  1493. }
  1494. p.nextToken()
  1495. switch p.curToken.Type {
  1496. case lexer.TokenREPLACE:
  1497. p.nextToken()
  1498. return ConflictReplace, true, nil
  1499. case lexer.TokenIGNORE:
  1500. p.nextToken()
  1501. return ConflictIgnore, true, nil
  1502. case lexer.TokenFAIL:
  1503. p.nextToken()
  1504. return ConflictFail, true, nil
  1505. case lexer.TokenABORT:
  1506. p.nextToken()
  1507. return ConflictAbort, true, nil
  1508. case lexer.TokenROLLBACK:
  1509. p.nextToken()
  1510. return ConflictRollback, true, nil
  1511. default:
  1512. return ConflictAbort, false, p.curError("expected REPLACE, IGNORE, FAIL, ABORT, or ROLLBACK after ON CONFLICT")
  1513. }
  1514. }
  1515. // parseForeignKeyClauses parses the optional ON DELETE/ON UPDATE referential
  1516. // actions and the optional DEFERRABLE clause that follow a REFERENCES target.
  1517. // Every action is parsed and persisted; the storage layer executes the
  1518. // cascading forms, and a DEFERRABLE clause is recorded so the DDL layer can
  1519. // reject it instead of silently weakening the constraint.
  1520. func (p *Parser) parseForeignKeyClauses(onDelete, onUpdate *ReferentialAction, deferrable *bool) error {
  1521. for p.curTokenIs(lexer.TokenON) {
  1522. p.nextToken()
  1523. var target *ReferentialAction
  1524. switch {
  1525. case p.curTokenIs(lexer.TokenDELETE):
  1526. target = onDelete
  1527. case p.curTokenIs(lexer.TokenUPDATE):
  1528. target = onUpdate
  1529. default:
  1530. return p.curError("expected DELETE or UPDATE after ON")
  1531. }
  1532. p.nextToken()
  1533. action, err := p.parseReferentialAction()
  1534. if err != nil {
  1535. return err
  1536. }
  1537. *target = action
  1538. }
  1539. if p.curTokenIs(lexer.TokenNOT) && p.peekToken.Type == lexer.TokenIdent && strings.EqualFold(p.peekToken.Literal, "DEFERRABLE") {
  1540. // NOT DEFERRABLE is the default; consume it so it parses. A following
  1541. // NOT NULL belongs to the column constraint list, so only consume NOT
  1542. // when DEFERRABLE actually follows.
  1543. p.nextToken()
  1544. p.nextToken()
  1545. return nil
  1546. }
  1547. if p.curIdentIs("DEFERRABLE") {
  1548. *deferrable = true
  1549. p.nextToken()
  1550. if p.curIdentIs("INITIALLY") {
  1551. p.nextToken()
  1552. switch {
  1553. case p.curIdentIs("DEFERRED"):
  1554. p.nextToken()
  1555. case p.curIdentIs("IMMEDIATE"):
  1556. p.nextToken()
  1557. default:
  1558. return p.curError("expected DEFERRED or IMMEDIATE after INITIALLY")
  1559. }
  1560. }
  1561. }
  1562. return nil
  1563. }
  1564. // parseReferentialAction parses one foreign-key action.
  1565. func (p *Parser) parseReferentialAction() (ReferentialAction, error) {
  1566. switch {
  1567. case p.curIdentIs("CASCADE"):
  1568. p.nextToken()
  1569. return RefActionCascade, nil
  1570. case p.curIdentIs("RESTRICT"):
  1571. p.nextToken()
  1572. return RefActionRestrict, nil
  1573. case p.curIdentIs("NO"):
  1574. p.nextToken()
  1575. if !p.curIdentIs("ACTION") {
  1576. return RefActionUnspecified, p.curError("expected ACTION after NO")
  1577. }
  1578. p.nextToken()
  1579. return RefActionNoAction, nil
  1580. case p.curTokenIs(lexer.TokenSET):
  1581. p.nextToken()
  1582. switch {
  1583. case p.curTokenIs(lexer.TokenNULL):
  1584. p.nextToken()
  1585. return RefActionSetNull, nil
  1586. case p.curTokenIs(lexer.TokenDEFAULT):
  1587. p.nextToken()
  1588. return RefActionSetDefault, nil
  1589. default:
  1590. return RefActionUnspecified, p.curError("expected NULL or DEFAULT after SET")
  1591. }
  1592. default:
  1593. return RefActionUnspecified, p.curError("expected CASCADE, RESTRICT, NO ACTION, SET NULL, or SET DEFAULT")
  1594. }
  1595. }
  1596. func (p *Parser) parseTableConstraint() (*TableConstraint, error) {
  1597. constraint := &TableConstraint{}
  1598. // Check for CONSTRAINT name
  1599. if p.curTokenIs(lexer.TokenCONSTRAINT) {
  1600. p.nextToken()
  1601. if !p.curTokenIs(lexer.TokenIdent) {
  1602. return nil, p.curError("expected constraint name")
  1603. }
  1604. constraint.Name = p.curToken.Literal
  1605. p.nextToken()
  1606. }
  1607. switch p.curToken.Type {
  1608. case lexer.TokenPRIMARY:
  1609. p.nextToken()
  1610. if !p.curTokenIs(lexer.TokenKEY) {
  1611. return nil, p.curError("expected KEY after PRIMARY")
  1612. }
  1613. p.nextToken()
  1614. constraint.Type = ConstraintPrimaryKey
  1615. cols, err := p.parseParenIdentList()
  1616. if err != nil {
  1617. return nil, err
  1618. }
  1619. constraint.Columns = cols
  1620. if action, ok, err := p.parseOnConflictAction(); err != nil {
  1621. return nil, err
  1622. } else if ok {
  1623. constraint.OnConflict = action
  1624. constraint.HasOnConflict = true
  1625. }
  1626. case lexer.TokenUNIQUE:
  1627. p.nextToken()
  1628. constraint.Type = ConstraintUnique
  1629. cols, err := p.parseParenIdentList()
  1630. if err != nil {
  1631. return nil, err
  1632. }
  1633. constraint.Columns = cols
  1634. if action, ok, err := p.parseOnConflictAction(); err != nil {
  1635. return nil, err
  1636. } else if ok {
  1637. constraint.OnConflict = action
  1638. constraint.HasOnConflict = true
  1639. }
  1640. case lexer.TokenFOREIGN:
  1641. p.nextToken()
  1642. if !p.curTokenIs(lexer.TokenKEY) {
  1643. return nil, p.curError("expected KEY after FOREIGN")
  1644. }
  1645. p.nextToken()
  1646. constraint.Type = ConstraintForeignKey
  1647. cols, err := p.parseParenIdentList()
  1648. if err != nil {
  1649. return nil, err
  1650. }
  1651. constraint.Columns = cols
  1652. if !p.curTokenIs(lexer.TokenREFERENCES) {
  1653. return nil, p.curError("expected REFERENCES")
  1654. }
  1655. p.nextToken()
  1656. if !p.curTokenIs(lexer.TokenIdent) {
  1657. return nil, p.curError("expected table name")
  1658. }
  1659. constraint.RefTable = p.curToken.Literal
  1660. p.nextToken()
  1661. refCols, err := p.parseParenIdentList()
  1662. if err != nil {
  1663. return nil, err
  1664. }
  1665. constraint.RefColumns = refCols
  1666. if err := p.parseForeignKeyClauses(&constraint.OnDelete, &constraint.OnUpdate, &constraint.Deferrable); err != nil {
  1667. return nil, err
  1668. }
  1669. case lexer.TokenCHECK:
  1670. p.nextToken()
  1671. constraint.Type = ConstraintCheck
  1672. if !p.curTokenIs(lexer.TokenLParen) {
  1673. return nil, p.curError("expected (")
  1674. }
  1675. p.nextToken()
  1676. check, err := p.parseExpr()
  1677. if err != nil {
  1678. return nil, err
  1679. }
  1680. constraint.Check = check
  1681. if !p.curTokenIs(lexer.TokenRParen) {
  1682. return nil, p.curError("expected )")
  1683. }
  1684. p.nextToken()
  1685. default:
  1686. return nil, p.curError("expected constraint type")
  1687. }
  1688. return constraint, nil
  1689. }
  1690. func (p *Parser) parseParenIdentList() ([]string, error) {
  1691. if !p.curTokenIs(lexer.TokenLParen) {
  1692. return nil, p.curError("expected (")
  1693. }
  1694. p.nextToken()
  1695. cols, err := p.parseIdentList()
  1696. if err != nil {
  1697. return nil, err
  1698. }
  1699. if !p.curTokenIs(lexer.TokenRParen) {
  1700. return nil, p.curError("expected )")
  1701. }
  1702. p.nextToken()
  1703. return cols, nil
  1704. }
  1705. // parseCreateIndex parses CREATE INDEX statements.
  1706. func (p *Parser) parseCreateIndex(unique bool) (*CreateIndexStmt, error) {
  1707. stmt := &CreateIndexStmt{Unique: unique}
  1708. p.nextToken() // consume INDEX
  1709. // Check for IF NOT EXISTS
  1710. if p.curTokenIs(lexer.TokenIF) {
  1711. p.nextToken()
  1712. if !p.curTokenIs(lexer.TokenNOT) {
  1713. return nil, p.curError("expected NOT")
  1714. }
  1715. p.nextToken()
  1716. if !p.curTokenIs(lexer.TokenEXISTS) {
  1717. return nil, p.curError("expected EXISTS")
  1718. }
  1719. stmt.IfNotExists = true
  1720. p.nextToken()
  1721. }
  1722. // Parse index name
  1723. if !p.curTokenIs(lexer.TokenIdent) {
  1724. return nil, p.curError("expected index name")
  1725. }
  1726. stmt.Name = p.curToken.Literal
  1727. p.nextToken()
  1728. // Expect ON
  1729. if !p.curTokenIs(lexer.TokenON) {
  1730. return nil, p.curError("expected ON")
  1731. }
  1732. p.nextToken()
  1733. // Parse table name
  1734. if !p.curTokenIs(lexer.TokenIdent) {
  1735. return nil, p.curError("expected table name")
  1736. }
  1737. stmt.Table = p.curToken.Literal
  1738. p.nextToken()
  1739. // PostgreSQL index methods. The engine only implements an ordered btree
  1740. // index, so a request for GIN (the jsonb index method) or any other method is
  1741. // rejected instead of silently creating a btree index with different
  1742. // performance and constraint behavior.
  1743. if p.curTokenIs(lexer.TokenUSING) {
  1744. p.nextToken()
  1745. if !p.curTokenIs(lexer.TokenIdent) {
  1746. return nil, p.curError("expected index method after USING")
  1747. }
  1748. method := strings.ToUpper(p.curToken.Literal)
  1749. p.nextToken()
  1750. if method != "BTREE" {
  1751. return nil, pgerror.Unsupported("index method %s is not supported; only BTREE indexes are implemented", method)
  1752. }
  1753. }
  1754. // Expect (
  1755. if !p.curTokenIs(lexer.TokenLParen) {
  1756. return nil, p.curError("expected (")
  1757. }
  1758. p.nextToken()
  1759. // Parse column list. Each element is either a bare column name or an
  1760. // arbitrary deterministic expression (e.g. lower(email)).
  1761. for {
  1762. if p.curTokenIs(lexer.TokenRParen) {
  1763. break
  1764. }
  1765. expr, err := p.parseExpr()
  1766. if err != nil {
  1767. return nil, err
  1768. }
  1769. col := IndexColumn{}
  1770. if ref, ok := expr.(*ColumnRef); ok && ref.Table == "" {
  1771. col.Name = ref.Column
  1772. } else {
  1773. col.Expr = expr
  1774. col.Name = FormatExpr(expr)
  1775. }
  1776. // Check for ASC/DESC
  1777. if p.curTokenIs(lexer.TokenASC) {
  1778. p.nextToken()
  1779. } else if p.curTokenIs(lexer.TokenDESC) {
  1780. col.Desc = true
  1781. p.nextToken()
  1782. }
  1783. stmt.Columns = append(stmt.Columns, col)
  1784. if p.curTokenIs(lexer.TokenComma) {
  1785. p.nextToken()
  1786. } else {
  1787. break
  1788. }
  1789. }
  1790. if !p.curTokenIs(lexer.TokenRParen) {
  1791. return nil, p.curError("expected )")
  1792. }
  1793. p.nextToken()
  1794. return stmt, nil
  1795. }
  1796. // parseDrop parses DROP statements.
  1797. func (p *Parser) parseDrop() (Statement, error) {
  1798. p.nextToken() // consume DROP
  1799. switch p.curToken.Type {
  1800. case lexer.TokenTABLE:
  1801. return p.parseDropTable()
  1802. case lexer.TokenINDEX:
  1803. return p.parseDropIndex()
  1804. case lexer.TokenVIEW:
  1805. return p.parseDropView()
  1806. default:
  1807. return nil, p.curError("expected TABLE or INDEX after DROP")
  1808. }
  1809. }
  1810. func (p *Parser) parseDropTable() (*DropTableStmt, error) {
  1811. stmt := &DropTableStmt{}
  1812. p.nextToken() // consume TABLE
  1813. // Check for IF EXISTS
  1814. if p.curTokenIs(lexer.TokenIF) {
  1815. p.nextToken()
  1816. if !p.curTokenIs(lexer.TokenEXISTS) {
  1817. return nil, p.curError("expected EXISTS")
  1818. }
  1819. stmt.IfExists = true
  1820. p.nextToken()
  1821. }
  1822. // Parse table names
  1823. for {
  1824. table, err := p.parseTableRef(false)
  1825. if err != nil {
  1826. return nil, err
  1827. }
  1828. stmt.Tables = append(stmt.Tables, table)
  1829. if !p.curTokenIs(lexer.TokenComma) {
  1830. break
  1831. }
  1832. p.nextToken()
  1833. }
  1834. return stmt, nil
  1835. }
  1836. func (p *Parser) parseDropIndex() (*DropIndexStmt, error) {
  1837. stmt := &DropIndexStmt{}
  1838. p.nextToken() // consume INDEX
  1839. // Check for IF EXISTS
  1840. if p.curTokenIs(lexer.TokenIF) {
  1841. p.nextToken()
  1842. if !p.curTokenIs(lexer.TokenEXISTS) {
  1843. return nil, p.curError("expected EXISTS")
  1844. }
  1845. stmt.IfExists = true
  1846. p.nextToken()
  1847. }
  1848. // Parse index name
  1849. if !p.curTokenIs(lexer.TokenIdent) {
  1850. return nil, p.curError("expected index name")
  1851. }
  1852. stmt.Name = p.curToken.Literal
  1853. p.nextToken()
  1854. return stmt, nil
  1855. }
  1856. func (p *Parser) parseCreateView() (*CreateViewStmt, error) {
  1857. stmt := &CreateViewStmt{}
  1858. p.nextToken() // consume VIEW
  1859. if p.curTokenIs(lexer.TokenIF) {
  1860. p.nextToken()
  1861. if !p.curTokenIs(lexer.TokenNOT) {
  1862. return nil, p.curError("expected NOT")
  1863. }
  1864. p.nextToken()
  1865. if !p.curTokenIs(lexer.TokenEXISTS) {
  1866. return nil, p.curError("expected EXISTS")
  1867. }
  1868. stmt.IfNotExists = true
  1869. p.nextToken()
  1870. }
  1871. // Parse view name directly — do NOT use parseTableRef here because it
  1872. // greedily interprets the AS keyword as an alias, consuming "AS SELECT".
  1873. if !p.curTokenIs(lexer.TokenIdent) {
  1874. return nil, p.curError("expected view name")
  1875. }
  1876. stmt.View = &TableRef{Name: p.curToken.Literal}
  1877. p.nextToken()
  1878. if !p.curTokenIs(lexer.TokenAS) {
  1879. return nil, p.curError("expected AS after view name")
  1880. }
  1881. p.nextToken() // consume AS
  1882. sel, err := p.parseSelect()
  1883. if err != nil {
  1884. return nil, err
  1885. }
  1886. stmt.Select = sel
  1887. return stmt, nil
  1888. }
  1889. func (p *Parser) parseDropView() (*DropViewStmt, error) {
  1890. stmt := &DropViewStmt{}
  1891. p.nextToken() // consume VIEW
  1892. if p.curTokenIs(lexer.TokenIF) {
  1893. p.nextToken()
  1894. if !p.curTokenIs(lexer.TokenEXISTS) {
  1895. return nil, p.curError("expected EXISTS")
  1896. }
  1897. stmt.IfExists = true
  1898. p.nextToken()
  1899. }
  1900. for {
  1901. view, err := p.parseTableRef(false)
  1902. if err != nil {
  1903. return nil, err
  1904. }
  1905. stmt.Views = append(stmt.Views, view)
  1906. if !p.curTokenIs(lexer.TokenComma) {
  1907. break
  1908. }
  1909. p.nextToken()
  1910. }
  1911. return stmt, nil
  1912. }
  1913. // parseAlter parses an ALTER statement.
  1914. func (p *Parser) parseAlter() (Statement, error) {
  1915. p.nextToken() // consume ALTER
  1916. if p.curTokenIs(lexer.TokenTABLE) {
  1917. return p.parseAlterTable()
  1918. }
  1919. return nil, p.curError("expected TABLE after ALTER")
  1920. }
  1921. // parseAlterTable parses an ALTER TABLE statement.
  1922. func (p *Parser) parseAlterTable() (*AlterTableStmt, error) {
  1923. stmt := &AlterTableStmt{}
  1924. p.nextToken() // consume TABLE
  1925. // Parse table name
  1926. if !p.curTokenIs(lexer.TokenIdent) {
  1927. return nil, p.curError("expected table name")
  1928. }
  1929. stmt.Table = p.curToken.Literal
  1930. p.nextToken()
  1931. // Parse action
  1932. switch p.curToken.Type {
  1933. case lexer.TokenADD:
  1934. return p.parseAlterTableAdd(stmt)
  1935. case lexer.TokenDROP:
  1936. return p.parseAlterTableDrop(stmt)
  1937. case lexer.TokenRENAME:
  1938. return p.parseAlterTableRename(stmt)
  1939. default:
  1940. return nil, p.curError("expected ADD, DROP, or RENAME")
  1941. }
  1942. }
  1943. // parseAlterTableAdd parses ALTER TABLE ADD COLUMN.
  1944. func (p *Parser) parseAlterTableAdd(stmt *AlterTableStmt) (*AlterTableStmt, error) {
  1945. p.nextToken() // consume ADD
  1946. // COLUMN keyword is optional
  1947. if p.curTokenIs(lexer.TokenCOLUMN) {
  1948. p.nextToken()
  1949. }
  1950. ifNotExists := false
  1951. if p.curTokenIs(lexer.TokenIF) {
  1952. ifNotExists = true
  1953. p.nextToken()
  1954. if !p.curTokenIs(lexer.TokenNOT) {
  1955. return nil, p.curError("expected NOT after IF")
  1956. }
  1957. p.nextToken()
  1958. if !p.curTokenIs(lexer.TokenEXISTS) {
  1959. return nil, p.curError("expected EXISTS after IF NOT")
  1960. }
  1961. p.nextToken()
  1962. }
  1963. // Parse column definition
  1964. col, err := p.parseColumnDef()
  1965. if err != nil {
  1966. return nil, err
  1967. }
  1968. stmt.Action = &AddColumnAction{Column: col, IfNotExists: ifNotExists}
  1969. return stmt, nil
  1970. }
  1971. // parseAlterTableDrop parses ALTER TABLE DROP COLUMN.
  1972. func (p *Parser) parseAlterTableDrop(stmt *AlterTableStmt) (*AlterTableStmt, error) {
  1973. p.nextToken() // consume DROP
  1974. // COLUMN keyword is optional in some databases but required in SQLite
  1975. if p.curTokenIs(lexer.TokenCOLUMN) {
  1976. p.nextToken()
  1977. }
  1978. // Parse column name
  1979. if !p.curIsName() {
  1980. return nil, p.curError("expected column name")
  1981. }
  1982. stmt.Action = &DropColumnAction{Column: p.curToken.Literal}
  1983. p.nextToken()
  1984. return stmt, nil
  1985. }
  1986. // parseAlterTableRename parses ALTER TABLE RENAME.
  1987. func (p *Parser) parseAlterTableRename(stmt *AlterTableStmt) (*AlterTableStmt, error) {
  1988. p.nextToken() // consume RENAME
  1989. // Check for RENAME TO (table rename) or RENAME COLUMN (column rename)
  1990. if p.curTokenIs(lexer.TokenTO) {
  1991. // RENAME TO newname
  1992. p.nextToken()
  1993. if !p.curTokenIs(lexer.TokenIdent) {
  1994. return nil, p.curError("expected new table name")
  1995. }
  1996. stmt.Action = &RenameTableAction{NewName: p.curToken.Literal}
  1997. p.nextToken()
  1998. } else if p.curTokenIs(lexer.TokenCOLUMN) {
  1999. // RENAME COLUMN oldname TO newname
  2000. p.nextToken()
  2001. if !p.curTokenIs(lexer.TokenIdent) {
  2002. return nil, p.curError("expected old column name")
  2003. }
  2004. oldName := p.curToken.Literal
  2005. p.nextToken()
  2006. if !p.curTokenIs(lexer.TokenTO) {
  2007. return nil, p.curError("expected TO")
  2008. }
  2009. p.nextToken()
  2010. if !p.curTokenIs(lexer.TokenIdent) {
  2011. return nil, p.curError("expected new column name")
  2012. }
  2013. newName := p.curToken.Literal
  2014. p.nextToken()
  2015. stmt.Action = &RenameColumnAction{OldName: oldName, NewName: newName}
  2016. } else {
  2017. return nil, p.curError("expected TO or COLUMN after RENAME")
  2018. }
  2019. return stmt, nil
  2020. }
  2021. // parsePragma parses a PRAGMA statement.
  2022. // Formats: PRAGMA name; PRAGMA name(arg); PRAGMA name = value;
  2023. func (p *Parser) parsePragma() (*PragmaStmt, error) {
  2024. stmt := &PragmaStmt{}
  2025. p.nextToken() // consume PRAGMA
  2026. // Parse pragma name
  2027. if !p.curTokenIs(lexer.TokenIdent) {
  2028. return nil, p.curError("expected pragma name")
  2029. }
  2030. stmt.Name = strings.ToLower(p.curToken.Literal)
  2031. p.nextToken()
  2032. // Check for argument in parentheses: PRAGMA table_info(tablename)
  2033. if p.curTokenIs(lexer.TokenLParen) {
  2034. p.nextToken()
  2035. if p.curTokenIs(lexer.TokenIdent) || p.curTokenIs(lexer.TokenString) {
  2036. stmt.Arg = p.curToken.Literal
  2037. p.nextToken()
  2038. }
  2039. if !p.curTokenIs(lexer.TokenRParen) {
  2040. return nil, p.curError("expected )")
  2041. }
  2042. p.nextToken()
  2043. }
  2044. // Check for value assignment: PRAGMA name = value
  2045. if p.curTokenIs(lexer.TokenEq) {
  2046. p.nextToken()
  2047. // ON is a keyword token, so it cannot start an expression. Accept it here
  2048. // as the value for boolean pragmas such as PRAGMA foreign_keys = ON.
  2049. if p.curTokenIs(lexer.TokenON) {
  2050. stmt.Value = &ColumnRef{Column: "on"}
  2051. p.nextToken()
  2052. return stmt, nil
  2053. }
  2054. val, err := p.parseExpr()
  2055. if err != nil {
  2056. return nil, err
  2057. }
  2058. stmt.Value = val
  2059. }
  2060. return stmt, nil
  2061. }
  2062. // parseSet parses a PostgreSQL SET statement. Drivers and ORMs issue session
  2063. // settings that have no effect on a PizzaSQL connection; the parser accepts the
  2064. // setting name and values so the executor can acknowledge them. Only
  2065. // search_path is retained, because current_schema() and pg_table_is_visible()
  2066. // report it.
  2067. func (p *Parser) parseSet() (*SetStmt, error) {
  2068. stmt := &SetStmt{}
  2069. p.nextToken() // consume SET
  2070. // SESSION CHARACTERISTICS AS TRANSACTION ... is a session-wide statement
  2071. // whose "SESSION" is not a scope modifier.
  2072. sessionCharacteristics := p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "SESSION") &&
  2073. p.peekTokenIs(lexer.TokenIdent) && strings.EqualFold(p.peekToken.Literal, "CHARACTERISTICS")
  2074. if !sessionCharacteristics && p.curTokenIs(lexer.TokenIdent) {
  2075. switch strings.ToUpper(p.curToken.Literal) {
  2076. case "LOCAL":
  2077. stmt.Local = true
  2078. p.nextToken()
  2079. case "SESSION":
  2080. p.nextToken()
  2081. }
  2082. }
  2083. var name strings.Builder
  2084. for p.isSettingNameToken() {
  2085. if name.Len() > 0 {
  2086. name.WriteByte(' ')
  2087. }
  2088. name.WriteString(p.curToken.Literal)
  2089. p.nextToken()
  2090. }
  2091. if name.Len() == 0 {
  2092. return nil, p.curError("expected setting name after SET")
  2093. }
  2094. stmt.Name = name.String()
  2095. if p.curTokenIs(lexer.TokenTO) || p.curTokenIs(lexer.TokenEq) {
  2096. p.nextToken()
  2097. }
  2098. // The remaining tokens are the setting value. They are retained as text for
  2099. // search_path and otherwise ignored, so forms such as SET TIME ZONE 'UTC',
  2100. // SET NAMES 'utf8', and SET SESSION CHARACTERISTICS AS TRANSACTION
  2101. // ISOLATION LEVEL READ COMMITTED parse without a value grammar.
  2102. for !p.curTokenIs(lexer.TokenSemicolon) && !p.curTokenIs(lexer.TokenEOF) {
  2103. switch p.curToken.Type {
  2104. case lexer.TokenIdent, lexer.TokenNumber, lexer.TokenString:
  2105. stmt.Values = append(stmt.Values, p.curToken.Literal)
  2106. }
  2107. p.nextToken()
  2108. }
  2109. return stmt, nil
  2110. }
  2111. // parseShow parses SHOW name. SHOW ALL is not supported because the engine has
  2112. // no settings catalog.
  2113. func (p *Parser) parseShow() (*ShowStmt, error) {
  2114. p.nextToken() // consume SHOW
  2115. if !p.isSettingNameToken() {
  2116. return nil, p.curError("expected setting name after SHOW")
  2117. }
  2118. var name strings.Builder
  2119. for p.isSettingNameToken() {
  2120. if name.Len() > 0 && p.curTokenIs(lexer.TokenIdent) {
  2121. name.WriteByte(' ')
  2122. }
  2123. name.WriteString(p.curToken.Literal)
  2124. p.nextToken()
  2125. }
  2126. return &ShowStmt{Name: name.String()}, nil
  2127. }
  2128. // isSettingNameToken reports whether the current token can be part of a SET or
  2129. // SHOW setting name. PostgreSQL setting names may contain non-reserved words
  2130. // that the lexer promotes to type keywords (TIME ZONE), so every token with
  2131. // literal text qualifies except the TO/= punctuation that starts the value.
  2132. func (p *Parser) isSettingNameToken() bool {
  2133. switch p.curToken.Type {
  2134. case lexer.TokenTO, lexer.TokenEq, lexer.TokenComma, lexer.TokenSemicolon,
  2135. lexer.TokenEOF, lexer.TokenLParen, lexer.TokenRParen:
  2136. return false
  2137. }
  2138. return p.curToken.Literal != ""
  2139. }
  2140. // parseAnalyze parses ANALYZE [schema.]table. PizzaSQL does not maintain
  2141. // optimizer statistics, so the statement is accepted and ignored at execution.
  2142. func (p *Parser) parseAnalyze() (*AnalyzeStmt, error) {
  2143. stmt := &AnalyzeStmt{}
  2144. p.nextToken() // consume ANALYZE
  2145. if p.curTokenIs(lexer.TokenIdent) {
  2146. stmt.Name = p.curToken.Literal
  2147. p.nextToken()
  2148. if p.curTokenIs(lexer.TokenDot) {
  2149. p.nextToken()
  2150. if !p.curTokenIs(lexer.TokenIdent) {
  2151. return nil, p.curError("expected table name after .")
  2152. }
  2153. stmt.Name = p.curToken.Literal
  2154. p.nextToken()
  2155. }
  2156. }
  2157. return stmt, nil
  2158. }
  2159. // parseExplain parses an EXPLAIN statement.
  2160. func (p *Parser) parseExplain() (*ExplainStmt, error) {
  2161. stmt := &ExplainStmt{}
  2162. p.nextToken() // consume EXPLAIN
  2163. // Check for QUERY PLAN. PLAN is not a reserved lexer keyword so it can be a
  2164. // column name; recognize it contextually here.
  2165. if p.curTokenIs(lexer.TokenQUERY) {
  2166. p.nextToken()
  2167. if !p.curIdentIs("PLAN") {
  2168. return nil, p.curError("expected PLAN after QUERY")
  2169. }
  2170. stmt.QueryPlan = true
  2171. p.nextToken()
  2172. }
  2173. // Parse the statement being explained
  2174. innerStmt, err := p.parseStatement()
  2175. if err != nil {
  2176. return nil, err
  2177. }
  2178. stmt.Statement = innerStmt
  2179. return stmt, nil
  2180. }
  2181. // Transaction statement parsing
  2182. // parseChannelName consumes a channel identifier. PostgreSQL channel names are
  2183. // identifiers (quoted or unquoted) and are limited to 63 bytes, matching
  2184. // NAMEDATALEN - 1.
  2185. func (p *Parser) parseChannelName() (string, error) {
  2186. if !p.curTokenIs(lexer.TokenIdent) {
  2187. return "", p.curError("expected channel name")
  2188. }
  2189. channel := p.curToken.Literal
  2190. if channel == "" {
  2191. return "", p.curError("channel name cannot be empty")
  2192. }
  2193. if len(channel) > 63 {
  2194. return "", p.curError("channel name is longer than 63 bytes")
  2195. }
  2196. p.nextToken()
  2197. return channel, nil
  2198. }
  2199. func (p *Parser) parseListen() (*ListenStmt, error) {
  2200. p.nextToken() // consume LISTEN
  2201. channel, err := p.parseChannelName()
  2202. if err != nil {
  2203. return nil, err
  2204. }
  2205. return &ListenStmt{Channel: channel}, nil
  2206. }
  2207. func (p *Parser) parseUnlisten() (*UnlistenStmt, error) {
  2208. p.nextToken() // consume UNLISTEN
  2209. if p.curTokenIs(lexer.TokenStar) {
  2210. p.nextToken()
  2211. return &UnlistenStmt{All: true}, nil
  2212. }
  2213. channel, err := p.parseChannelName()
  2214. if err != nil {
  2215. return nil, err
  2216. }
  2217. return &UnlistenStmt{Channel: channel}, nil
  2218. }
  2219. func (p *Parser) parseNotify() (*NotifyStmt, error) {
  2220. p.nextToken() // consume NOTIFY
  2221. channel, err := p.parseChannelName()
  2222. if err != nil {
  2223. return nil, err
  2224. }
  2225. stmt := &NotifyStmt{Channel: channel}
  2226. if p.curTokenIs(lexer.TokenComma) {
  2227. p.nextToken()
  2228. if !p.curTokenIs(lexer.TokenString) {
  2229. return nil, p.curError("expected notification payload string")
  2230. }
  2231. if len(p.curToken.Literal) > 8000 {
  2232. return nil, p.curError("notification payload is longer than 8000 bytes")
  2233. }
  2234. stmt.Payload = p.curToken.Literal
  2235. p.nextToken()
  2236. }
  2237. return stmt, nil
  2238. }
  2239. func (p *Parser) parseBegin() (*BeginStmt, error) {
  2240. stmt := &BeginStmt{}
  2241. p.nextToken() // consume BEGIN
  2242. // Optional TRANSACTION keyword
  2243. if p.curTokenIs(lexer.TokenTRANSACTION) {
  2244. p.nextToken()
  2245. }
  2246. return stmt, nil
  2247. }
  2248. func (p *Parser) parseCommit() (*CommitStmt, error) {
  2249. p.nextToken() // consume COMMIT
  2250. // Optional TRANSACTION keyword
  2251. if p.curTokenIs(lexer.TokenTRANSACTION) {
  2252. p.nextToken()
  2253. }
  2254. return &CommitStmt{}, nil
  2255. }
  2256. func (p *Parser) parseRollback() (*RollbackStmt, error) {
  2257. stmt := &RollbackStmt{}
  2258. p.nextToken() // consume ROLLBACK
  2259. // Check for ROLLBACK TO [SAVEPOINT] name
  2260. if p.curTokenIs(lexer.TokenTO) {
  2261. p.nextToken()
  2262. // Optional SAVEPOINT keyword
  2263. if p.curTokenIs(lexer.TokenSAVEPOINT) {
  2264. p.nextToken()
  2265. }
  2266. if !p.curTokenIs(lexer.TokenIdent) {
  2267. return nil, p.curError("expected savepoint name")
  2268. }
  2269. stmt.Savepoint = p.curToken.Literal
  2270. p.nextToken()
  2271. } else if p.curTokenIs(lexer.TokenTRANSACTION) {
  2272. // Optional TRANSACTION keyword
  2273. p.nextToken()
  2274. }
  2275. return stmt, nil
  2276. }
  2277. func (p *Parser) parseSavepoint() (*SavepointStmt, error) {
  2278. p.nextToken() // consume SAVEPOINT
  2279. if !p.curTokenIs(lexer.TokenIdent) {
  2280. return nil, p.curError("expected savepoint name")
  2281. }
  2282. stmt := &SavepointStmt{Name: p.curToken.Literal}
  2283. p.nextToken()
  2284. return stmt, nil
  2285. }
  2286. func (p *Parser) parseRelease() (*ReleaseStmt, error) {
  2287. p.nextToken() // consume RELEASE
  2288. // Optional SAVEPOINT keyword
  2289. if p.curTokenIs(lexer.TokenSAVEPOINT) {
  2290. p.nextToken()
  2291. }
  2292. if !p.curTokenIs(lexer.TokenIdent) {
  2293. return nil, p.curError("expected savepoint name")
  2294. }
  2295. stmt := &ReleaseStmt{Name: p.curToken.Literal}
  2296. p.nextToken()
  2297. return stmt, nil
  2298. }
  2299. // parseAttach parses an ATTACH DATABASE statement.
  2300. // Syntax: ATTACH [DATABASE] 'filepath' AS alias
  2301. func (p *Parser) parseAttach() (*AttachStmt, error) {
  2302. stmt := &AttachStmt{}
  2303. p.nextToken() // consume ATTACH
  2304. // Optional DATABASE keyword
  2305. if p.curTokenIs(lexer.TokenDATABASE) {
  2306. p.nextToken()
  2307. }
  2308. // Parse file path (string literal)
  2309. if !p.curTokenIs(lexer.TokenString) {
  2310. return nil, p.curError("expected database file path (string)")
  2311. }
  2312. stmt.FilePath = p.curToken.Literal
  2313. p.nextToken()
  2314. // Expect AS keyword
  2315. if !p.curTokenIs(lexer.TokenAS) {
  2316. return nil, p.curError("expected AS")
  2317. }
  2318. p.nextToken()
  2319. // Parse database alias
  2320. if !p.curTokenIs(lexer.TokenIdent) {
  2321. return nil, p.curError("expected database alias")
  2322. }
  2323. stmt.Alias = p.curToken.Literal
  2324. p.nextToken()
  2325. return stmt, nil
  2326. }
  2327. // parseDetach parses a DETACH DATABASE statement.
  2328. // Syntax: DETACH [DATABASE] alias
  2329. func (p *Parser) parseDetach() (*DetachStmt, error) {
  2330. stmt := &DetachStmt{}
  2331. p.nextToken() // consume DETACH
  2332. // Optional DATABASE keyword
  2333. if p.curTokenIs(lexer.TokenDATABASE) {
  2334. p.nextToken()
  2335. }
  2336. // Parse database alias
  2337. if !p.curTokenIs(lexer.TokenIdent) {
  2338. return nil, p.curError("expected database alias")
  2339. }
  2340. stmt.Alias = p.curToken.Literal
  2341. p.nextToken()
  2342. return stmt, nil
  2343. }
  2344. // Expression parsing with operator precedence
  2345. func (p *Parser) parseExpr() (Expr, error) {
  2346. return p.parseOrExpr()
  2347. }
  2348. func (p *Parser) parseOrExpr() (Expr, error) {
  2349. left, err := p.parseAndExpr()
  2350. if err != nil {
  2351. return nil, err
  2352. }
  2353. for p.curTokenIs(lexer.TokenOR) {
  2354. op := p.curToken.Type
  2355. p.nextToken()
  2356. right, err := p.parseAndExpr()
  2357. if err != nil {
  2358. return nil, err
  2359. }
  2360. left = &BinaryExpr{Left: left, Op: op, Right: right}
  2361. }
  2362. return left, nil
  2363. }
  2364. func (p *Parser) parseAndExpr() (Expr, error) {
  2365. left, err := p.parseNotExpr()
  2366. if err != nil {
  2367. return nil, err
  2368. }
  2369. for p.curTokenIs(lexer.TokenAND) {
  2370. op := p.curToken.Type
  2371. p.nextToken()
  2372. right, err := p.parseNotExpr()
  2373. if err != nil {
  2374. return nil, err
  2375. }
  2376. left = &BinaryExpr{Left: left, Op: op, Right: right}
  2377. }
  2378. return left, nil
  2379. }
  2380. func (p *Parser) parseNotExpr() (Expr, error) {
  2381. if p.curTokenIs(lexer.TokenNOT) {
  2382. p.nextToken()
  2383. operand, err := p.parseNotExpr()
  2384. if err != nil {
  2385. return nil, err
  2386. }
  2387. return &UnaryExpr{Op: lexer.TokenNOT, Operand: operand}, nil
  2388. }
  2389. return p.parseComparisonExpr()
  2390. }
  2391. func (p *Parser) parseComparisonExpr() (Expr, error) {
  2392. left, err := p.parseBitwiseExpr()
  2393. if err != nil {
  2394. return nil, err
  2395. }
  2396. // Handle IS NULL / IS NOT NULL and IS [NOT] DISTINCT FROM.
  2397. if p.curTokenIs(lexer.TokenIS) {
  2398. p.nextToken()
  2399. not := false
  2400. if p.curTokenIs(lexer.TokenNOT) {
  2401. not = true
  2402. p.nextToken()
  2403. }
  2404. if p.curTokenIs(lexer.TokenDISTINCT) {
  2405. p.nextToken()
  2406. if !p.curTokenIs(lexer.TokenFROM) {
  2407. return nil, p.curError("expected FROM after IS [NOT] DISTINCT")
  2408. }
  2409. p.nextToken()
  2410. right, err := p.parseBitwiseExpr()
  2411. if err != nil {
  2412. return nil, err
  2413. }
  2414. return &IsDistinctExpr{Left: left, Right: right, Not: not}, nil
  2415. }
  2416. if !p.curTokenIs(lexer.TokenNULL) {
  2417. return nil, p.curError("expected NULL or DISTINCT FROM after IS")
  2418. }
  2419. p.nextToken()
  2420. return &IsNullExpr{Left: left, Not: not}, nil
  2421. }
  2422. // Handle IN / NOT IN
  2423. not := false
  2424. if p.curTokenIs(lexer.TokenNOT) {
  2425. not = true
  2426. p.nextToken()
  2427. }
  2428. if p.curTokenIs(lexer.TokenIN) {
  2429. p.nextToken()
  2430. return p.parseInExpr(left, not)
  2431. }
  2432. // Handle BETWEEN
  2433. if p.curTokenIs(lexer.TokenBETWEEN) {
  2434. p.nextToken()
  2435. return p.parseBetweenExpr(left, not)
  2436. }
  2437. // Handle LIKE
  2438. if p.curTokenIs(lexer.TokenLIKE) {
  2439. p.nextToken()
  2440. return p.parseLikeExpr(left, not)
  2441. }
  2442. // If we consumed NOT but didn't find IN/BETWEEN/LIKE, it's an error
  2443. if not {
  2444. return nil, p.curError("expected IN, BETWEEN, or LIKE after NOT")
  2445. }
  2446. // JSONB containment and existence operators share the comparison layer:
  2447. // they bind looser than + and || and tighter than NOT/AND/OR.
  2448. if isJSONBPredicateOp(p.curToken.Type) {
  2449. op := p.curToken.Type
  2450. p.nextToken()
  2451. right, err := p.parseBitwiseExpr()
  2452. if err != nil {
  2453. return nil, err
  2454. }
  2455. return &BinaryExpr{Left: left, Op: op, Right: right}, nil
  2456. }
  2457. if p.curTokenIs(lexer.TokenAtQuestion) || p.curTokenIs(lexer.TokenAtAt) {
  2458. return nil, pgerror.Unsupported("jsonpath operators @? and @@ are not supported")
  2459. }
  2460. // Handle comparison operators, including the quantified forms
  2461. // `expr op ANY(array)` and `expr op ALL(array)`.
  2462. if isComparisonOp(p.curToken.Type) {
  2463. op := p.curToken.Type
  2464. p.nextToken()
  2465. if p.curTokenIs(lexer.TokenALL) && p.peekTokenIs(lexer.TokenLParen) {
  2466. p.nextToken() // ALL
  2467. array, err := p.parseQuantifierArray()
  2468. if err != nil {
  2469. return nil, err
  2470. }
  2471. return &AnyAllExpr{Left: left, Op: op, All: true, Array: array}, nil
  2472. }
  2473. if p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "ANY") && p.peekTokenIs(lexer.TokenLParen) {
  2474. p.nextToken() // ANY
  2475. array, err := p.parseQuantifierArray()
  2476. if err != nil {
  2477. return nil, err
  2478. }
  2479. return &AnyAllExpr{Left: left, Op: op, Array: array}, nil
  2480. }
  2481. right, err := p.parseBitwiseExpr()
  2482. if err != nil {
  2483. return nil, err
  2484. }
  2485. return &BinaryExpr{Left: left, Op: op, Right: right}, nil
  2486. }
  2487. return left, nil
  2488. }
  2489. // parseQuantifierArray parses the parenthesized operand of ANY(...) or
  2490. // ALL(...). Arrays are the only supported operand; a subquery would need a
  2491. // materialized set the executor does not build for this form.
  2492. func (p *Parser) parseQuantifierArray() (Expr, error) {
  2493. if !p.curTokenIs(lexer.TokenLParen) {
  2494. return nil, p.curError("expected ( after ANY or ALL")
  2495. }
  2496. p.nextToken()
  2497. if p.curTokenIs(lexer.TokenSELECT) {
  2498. return nil, pgerror.Unsupported("ANY/ALL over a subquery is not supported; pass an array value instead")
  2499. }
  2500. array, err := p.parseExpr()
  2501. if err != nil {
  2502. return nil, err
  2503. }
  2504. if !p.curTokenIs(lexer.TokenRParen) {
  2505. return nil, p.curError("expected ) after ANY/ALL operand")
  2506. }
  2507. p.nextToken()
  2508. return array, nil
  2509. }
  2510. // parseArrayConstructor parses ARRAY[...] with the current token on ARRAY.
  2511. // Nested constructors and nested array literals are rejected: PizzaSQL has no
  2512. // multidimensional arrays.
  2513. func (p *Parser) parseArrayConstructor() (Expr, error) {
  2514. p.nextToken() // ARRAY
  2515. if !p.curTokenIs(lexer.TokenLBracket) {
  2516. return nil, p.curError("expected [ after ARRAY")
  2517. }
  2518. p.nextToken()
  2519. expr := &ArrayExpr{}
  2520. if p.curTokenIs(lexer.TokenRBracket) {
  2521. p.nextToken()
  2522. return expr, nil
  2523. }
  2524. for {
  2525. // A bracketed identifier here is ARRAY[[...]] (or ARRAY[[col]]): the
  2526. // lexer reads the inner brackets as SQLite quoting, so report the
  2527. // nested-array shape explicitly instead of resolving a bogus column.
  2528. if p.curTokenIs(lexer.TokenIdent) && p.curToken.Bracketed {
  2529. return nil, pgerror.Unsupported("multidimensional arrays are not supported; ARRAY[...] elements must be scalars")
  2530. }
  2531. element, err := p.parseExpr()
  2532. if err != nil {
  2533. return nil, err
  2534. }
  2535. if _, nested := element.(*ArrayExpr); nested {
  2536. return nil, pgerror.Unsupported("multidimensional arrays are not supported; ARRAY[...] elements must be scalars")
  2537. }
  2538. expr.Elements = append(expr.Elements, element)
  2539. if p.curTokenIs(lexer.TokenComma) {
  2540. p.nextToken()
  2541. continue
  2542. }
  2543. if !p.curTokenIs(lexer.TokenRBracket) {
  2544. return nil, p.curError("expected ] after ARRAY elements")
  2545. }
  2546. p.nextToken()
  2547. return expr, nil
  2548. }
  2549. }
  2550. func isComparisonOp(t lexer.TokenType) bool {
  2551. switch t {
  2552. case lexer.TokenEq, lexer.TokenNeq, lexer.TokenLt,
  2553. lexer.TokenLte, lexer.TokenGt, lexer.TokenGte:
  2554. return true
  2555. }
  2556. return false
  2557. }
  2558. // isJSONBPredicateOp reports whether t is a jsonb containment or key-existence
  2559. // operator. They parse at comparison precedence as a single binary predicate.
  2560. func isJSONBPredicateOp(t lexer.TokenType) bool {
  2561. switch t {
  2562. case lexer.TokenAtArrow, lexer.TokenLtAt,
  2563. lexer.TokenQuestion, lexer.TokenQuestionPipe, lexer.TokenQuestionAmp:
  2564. return true
  2565. }
  2566. return false
  2567. }
  2568. // parseBitwiseExpr parses the SQLite bitwise layer: << >> & | bind more tightly
  2569. // than comparisons but more loosely than + and -.
  2570. func (p *Parser) parseBitwiseExpr() (Expr, error) {
  2571. left, err := p.parseAddExpr()
  2572. if err != nil {
  2573. return nil, err
  2574. }
  2575. for {
  2576. switch p.curToken.Type {
  2577. case lexer.TokenShiftLeft, lexer.TokenShiftRight, lexer.TokenBitAnd, lexer.TokenBitOr:
  2578. op := p.curToken.Type
  2579. p.nextToken()
  2580. right, err := p.parseAddExpr()
  2581. if err != nil {
  2582. return nil, err
  2583. }
  2584. left = &BinaryExpr{Left: left, Op: op, Right: right}
  2585. default:
  2586. return left, nil
  2587. }
  2588. }
  2589. }
  2590. func (p *Parser) parseInExpr(left Expr, not bool) (Expr, error) {
  2591. expr := &InExpr{Left: left, Not: not}
  2592. if !p.curTokenIs(lexer.TokenLParen) {
  2593. return nil, p.curError("expected (")
  2594. }
  2595. p.nextToken()
  2596. // Check for subquery
  2597. if p.curTokenIs(lexer.TokenSELECT) {
  2598. sel, err := p.parseSelect()
  2599. if err != nil {
  2600. return nil, err
  2601. }
  2602. expr.Subquery = sel
  2603. } else if !p.curTokenIs(lexer.TokenRParen) {
  2604. // Value list (empty list is allowed — always false)
  2605. values, err := p.parseExprList()
  2606. if err != nil {
  2607. return nil, err
  2608. }
  2609. expr.Values = values
  2610. }
  2611. if !p.curTokenIs(lexer.TokenRParen) {
  2612. return nil, p.curError("expected )")
  2613. }
  2614. p.nextToken()
  2615. return expr, nil
  2616. }
  2617. func (p *Parser) parseBetweenExpr(left Expr, not bool) (Expr, error) {
  2618. low, err := p.parseBitwiseExpr()
  2619. if err != nil {
  2620. return nil, err
  2621. }
  2622. if !p.curTokenIs(lexer.TokenAND) {
  2623. return nil, p.curError("expected AND in BETWEEN")
  2624. }
  2625. p.nextToken()
  2626. high, err := p.parseBitwiseExpr()
  2627. if err != nil {
  2628. return nil, err
  2629. }
  2630. return &BetweenExpr{Left: left, Not: not, Low: low, High: high}, nil
  2631. }
  2632. func (p *Parser) parseLikeExpr(left Expr, not bool) (Expr, error) {
  2633. pattern, err := p.parseBitwiseExpr()
  2634. if err != nil {
  2635. return nil, err
  2636. }
  2637. expr := &LikeExpr{Left: left, Not: not, Pattern: pattern}
  2638. // Check for ESCAPE
  2639. if p.curTokenIs(lexer.TokenESCAPE) {
  2640. p.nextToken()
  2641. esc, err := p.parseBitwiseExpr()
  2642. if err != nil {
  2643. return nil, err
  2644. }
  2645. expr.Escape = esc
  2646. }
  2647. return expr, nil
  2648. }
  2649. func (p *Parser) parseAddExpr() (Expr, error) {
  2650. left, err := p.parseMulExpr()
  2651. if err != nil {
  2652. return nil, err
  2653. }
  2654. for p.curTokenIs(lexer.TokenPlus) || p.curTokenIs(lexer.TokenMinus) || p.curTokenIs(lexer.TokenConcat) {
  2655. op := p.curToken.Type
  2656. p.nextToken()
  2657. right, err := p.parseMulExpr()
  2658. if err != nil {
  2659. return nil, err
  2660. }
  2661. left = &BinaryExpr{Left: left, Op: op, Right: right}
  2662. }
  2663. return left, nil
  2664. }
  2665. func (p *Parser) parseMulExpr() (Expr, error) {
  2666. left, err := p.parseJSONExpr()
  2667. if err != nil {
  2668. return nil, err
  2669. }
  2670. for p.curTokenIs(lexer.TokenStar) || p.curTokenIs(lexer.TokenSlash) || p.curTokenIs(lexer.TokenPercent) {
  2671. op := p.curToken.Type
  2672. p.nextToken()
  2673. right, err := p.parseJSONExpr()
  2674. if err != nil {
  2675. return nil, err
  2676. }
  2677. left = &BinaryExpr{Left: left, Op: op, Right: right}
  2678. }
  2679. return left, nil
  2680. }
  2681. // parseJSONExpr parses the JSON extraction and path operators ->, ->>, #>,
  2682. // #>>, and #-.
  2683. //
  2684. // Precedence: they bind tighter than multiplicative, additive/concatenation,
  2685. // bitwise, and comparison operators, and looser than unary -, +, and ~. So
  2686. // "a -> 'x' || 'y'" concatenates the extracted value, "a -> 'x' = 1" compares
  2687. // it, and "-a -> 'x'" negates a before extraction. They are left-associative,
  2688. // so "a -> 'x' -> 0" extracts 'x' and then indexes the result at 0.
  2689. func (p *Parser) parseJSONExpr() (Expr, error) {
  2690. left, err := p.parseUnaryExpr()
  2691. if err != nil {
  2692. return nil, err
  2693. }
  2694. for {
  2695. switch p.curToken.Type {
  2696. case lexer.TokenArrow, lexer.TokenArrowText,
  2697. lexer.TokenHashArrow, lexer.TokenHashArrowText, lexer.TokenHashMinus:
  2698. op := p.curToken.Type
  2699. p.nextToken()
  2700. right, err := p.parseUnaryExpr()
  2701. if err != nil {
  2702. return nil, err
  2703. }
  2704. left = &BinaryExpr{Left: left, Op: op, Right: right}
  2705. default:
  2706. return left, nil
  2707. }
  2708. }
  2709. }
  2710. func (p *Parser) parseUnaryExpr() (Expr, error) {
  2711. if p.curTokenIs(lexer.TokenMinus) || p.curTokenIs(lexer.TokenPlus) || p.curTokenIs(lexer.TokenBitNot) {
  2712. op := p.curToken.Type
  2713. p.nextToken()
  2714. operand, err := p.parseUnaryExpr()
  2715. if err != nil {
  2716. return nil, err
  2717. }
  2718. return &UnaryExpr{Op: op, Operand: operand}, nil
  2719. }
  2720. return p.parsePrimaryExpr()
  2721. }
  2722. // parsePrimaryExpr parses a primary expression and applies the postfix
  2723. // operators that bind tighter than any prefix operator: array element
  2724. // subscripts (arr[idx]) and PostgreSQL-style casts (expr::type).
  2725. func (p *Parser) parsePrimaryExpr() (Expr, error) {
  2726. expr, err := p.parsePrimaryExprBase()
  2727. if err != nil {
  2728. return nil, err
  2729. }
  2730. for {
  2731. switch {
  2732. case p.curTokenIs(lexer.TokenLBracket):
  2733. p.nextToken()
  2734. index, indexErr := p.parseExpr()
  2735. if indexErr != nil {
  2736. return nil, indexErr
  2737. }
  2738. if !p.curTokenIs(lexer.TokenRBracket) {
  2739. return nil, p.curError("expected ] after array subscript")
  2740. }
  2741. p.nextToken()
  2742. expr = &SubscriptExpr{Expr: expr, Index: index}
  2743. case p.curTokenIs(lexer.TokenColonColon):
  2744. p.nextToken()
  2745. dataType, typeErr := p.parseDataType()
  2746. if typeErr != nil {
  2747. return nil, typeErr
  2748. }
  2749. expr = &CastExpr{Expr: expr, Type: *dataType}
  2750. default:
  2751. return expr, nil
  2752. }
  2753. }
  2754. }
  2755. func (p *Parser) parsePrimaryExprBase() (Expr, error) {
  2756. switch p.curToken.Type {
  2757. case lexer.TokenALL:
  2758. if p.peekTokenIs(lexer.TokenLParen) {
  2759. return nil, pgerror.Unsupported("ALL(...) is a quantified predicate and must follow a comparison operator, as in expr <> ALL(array)")
  2760. }
  2761. return nil, p.curError("unexpected token in expression: " + p.curToken.Type.String())
  2762. case lexer.TokenNumber:
  2763. expr := &LiteralExpr{Type: lexer.TokenNumber, Value: p.curToken.Literal}
  2764. p.nextToken()
  2765. return expr, nil
  2766. case lexer.TokenString:
  2767. expr := &LiteralExpr{Type: lexer.TokenString, Value: p.curToken.Literal}
  2768. p.nextToken()
  2769. return expr, nil
  2770. case lexer.TokenBlob:
  2771. expr := &LiteralExpr{Type: lexer.TokenBlob, Value: p.curToken.Literal}
  2772. p.nextToken()
  2773. return expr, nil
  2774. case lexer.TokenNULL:
  2775. expr := &LiteralExpr{Type: lexer.TokenNULL, Value: "NULL"}
  2776. p.nextToken()
  2777. return expr, nil
  2778. case lexer.TokenTRUE:
  2779. expr := &LiteralExpr{Type: lexer.TokenTRUE, Value: "TRUE"}
  2780. p.nextToken()
  2781. return expr, nil
  2782. case lexer.TokenFALSE:
  2783. expr := &LiteralExpr{Type: lexer.TokenFALSE, Value: "FALSE"}
  2784. p.nextToken()
  2785. return expr, nil
  2786. case lexer.TokenLParen:
  2787. p.nextToken()
  2788. // Check for subquery
  2789. if p.curTokenIs(lexer.TokenSELECT) {
  2790. sel, err := p.parseSelect()
  2791. if err != nil {
  2792. return nil, err
  2793. }
  2794. if !p.curTokenIs(lexer.TokenRParen) {
  2795. return nil, p.curError("expected )")
  2796. }
  2797. p.nextToken()
  2798. return &SubqueryExpr{Query: sel}, nil
  2799. }
  2800. // Regular parenthesized expression
  2801. expr, err := p.parseExpr()
  2802. if err != nil {
  2803. return nil, err
  2804. }
  2805. if !p.curTokenIs(lexer.TokenRParen) {
  2806. return nil, p.curError("expected )")
  2807. }
  2808. p.nextToken()
  2809. return &ParenExpr{Expr: expr}, nil
  2810. case lexer.TokenCASE:
  2811. return p.parseCaseExpr()
  2812. case lexer.TokenCAST:
  2813. return p.parseCastExpr()
  2814. case lexer.TokenEXISTS:
  2815. return p.parseExistsExpr()
  2816. case lexer.TokenCOALESCE, lexer.TokenNULLIF, lexer.TokenIF, lexer.TokenREPLACE, lexer.TokenGLOB:
  2817. // These keywords can be used as function names
  2818. return p.parseKeywordFunction()
  2819. case lexer.TokenJSON, lexer.TokenJSONB:
  2820. // json(expr) / jsonb(expr) are JSON1 constructor functions. They lex as
  2821. // data-type keywords but are also callable.
  2822. return p.parseIdentOrFunction()
  2823. case lexer.TokenDATE, lexer.TokenTIME, lexer.TokenTIMESTAMP, lexer.TokenDATETIME:
  2824. // Date/time functions (date(), time(), datetime(), ...) lex as data-type
  2825. // keywords but are callable.
  2826. return p.parseIdentOrFunction()
  2827. case lexer.TokenKEY:
  2828. // KEY is a lexer keyword (PRIMARY KEY) that SQLite also permits as a
  2829. // column name, e.g. store.key.
  2830. return p.parseIdentOrFunction()
  2831. case lexer.TokenIdent:
  2832. if strings.EqualFold(p.curToken.Literal, "ARRAY") && p.peekTokenIs(lexer.TokenLBracket) {
  2833. return p.parseArrayConstructor()
  2834. }
  2835. return p.parseIdentOrFunction()
  2836. case lexer.TokenStar:
  2837. // For COUNT(*)
  2838. expr := &LiteralExpr{Type: lexer.TokenStar, Value: "*"}
  2839. p.nextToken()
  2840. return expr, nil
  2841. default:
  2842. return nil, p.curError("unexpected token in expression: " + p.curToken.Type.String())
  2843. }
  2844. }
  2845. func (p *Parser) parseIdentOrFunction() (Expr, error) {
  2846. name := p.curToken.Literal
  2847. p.nextToken()
  2848. // Check for function call
  2849. if p.curTokenIs(lexer.TokenLParen) {
  2850. if strings.EqualFold(name, "ANY") {
  2851. return nil, pgerror.Unsupported("ANY(...) is a quantified predicate and must follow a comparison operator, as in expr = ANY(array)")
  2852. }
  2853. return p.parseFunctionCall(name)
  2854. }
  2855. // Check for table.column. KEY is a lexer keyword but SQLite also permits it
  2856. // as a column name, and jsonb_each's first output column is named key.
  2857. if p.curTokenIs(lexer.TokenDot) {
  2858. p.nextToken()
  2859. if !p.curTokenIs(lexer.TokenIdent) && !p.curTokenIs(lexer.TokenStar) && !p.curTokenIs(lexer.TokenKEY) {
  2860. return nil, p.curError("expected column name after dot")
  2861. }
  2862. col := p.curToken.Literal
  2863. // A schema-qualified function call (pg_catalog.format_type(...)) keeps
  2864. // the bare function name: the engine has one function namespace.
  2865. if p.peekTokenIs(lexer.TokenLParen) {
  2866. p.nextToken()
  2867. return p.parseFunctionCall(col)
  2868. }
  2869. p.nextToken()
  2870. return &ColumnRef{Table: name, Column: col}, nil
  2871. }
  2872. return &ColumnRef{Column: name}, nil
  2873. }
  2874. func (p *Parser) parseKeywordFunction() (Expr, error) {
  2875. // Handle keywords that can be used as function names (COALESCE, NULLIF, IF, REPLACE, GLOB)
  2876. name := strings.ToUpper(p.curToken.Literal)
  2877. p.nextToken()
  2878. if !p.curTokenIs(lexer.TokenLParen) {
  2879. return nil, p.curError("expected ( after " + name)
  2880. }
  2881. return p.parseFunctionCall(name)
  2882. }
  2883. func (p *Parser) parseFunctionCall(name string) (Expr, error) {
  2884. fn := &FunctionCall{Name: strings.ToUpper(name)}
  2885. p.nextToken() // consume (
  2886. // Check for DISTINCT or ALL
  2887. if p.curTokenIs(lexer.TokenDISTINCT) {
  2888. fn.Distinct = true
  2889. p.nextToken()
  2890. } else if p.curTokenIs(lexer.TokenALL) {
  2891. // ALL is the default behavior, just skip it
  2892. p.nextToken()
  2893. }
  2894. // Check for * (COUNT(*))
  2895. if p.curTokenIs(lexer.TokenStar) {
  2896. fn.Star = true
  2897. p.nextToken()
  2898. } else if !p.curTokenIs(lexer.TokenRParen) {
  2899. // Parse arguments
  2900. args, err := p.parseExprList()
  2901. if err != nil {
  2902. return nil, err
  2903. }
  2904. fn.Args = args
  2905. }
  2906. if !p.curTokenIs(lexer.TokenRParen) {
  2907. return nil, p.curError("expected )")
  2908. }
  2909. p.nextToken()
  2910. // Window function: func(...) OVER (PARTITION BY ... ORDER BY ...).
  2911. if p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "OVER") {
  2912. return p.parseWindowSpec(fn)
  2913. }
  2914. return fn, nil
  2915. }
  2916. // parseWindowSpec parses the OVER (...) clause of a window function. Only
  2917. // PARTITION BY and ORDER BY are supported; frame clauses are not.
  2918. func (p *Parser) parseWindowSpec(fn *FunctionCall) (Expr, error) {
  2919. p.nextToken() // consume OVER
  2920. if !p.curTokenIs(lexer.TokenLParen) {
  2921. return nil, p.curError("expected ( after OVER")
  2922. }
  2923. p.nextToken()
  2924. window := &WindowExpr{Func: fn}
  2925. if p.curTokenIs(lexer.TokenIdent) && strings.EqualFold(p.curToken.Literal, "PARTITION") {
  2926. p.nextToken()
  2927. if !p.curTokenIs(lexer.TokenBY) {
  2928. return nil, p.curError("expected BY after PARTITION")
  2929. }
  2930. p.nextToken()
  2931. exprs, err := p.parseExprList()
  2932. if err != nil {
  2933. return nil, err
  2934. }
  2935. window.PartitionBy = exprs
  2936. }
  2937. if p.curTokenIs(lexer.TokenORDER) {
  2938. p.nextToken()
  2939. if !p.curTokenIs(lexer.TokenBY) {
  2940. return nil, p.curError("expected BY after ORDER")
  2941. }
  2942. p.nextToken()
  2943. orderBy, err := p.parseOrderBy()
  2944. if err != nil {
  2945. return nil, err
  2946. }
  2947. window.OrderBy = orderBy
  2948. }
  2949. if !p.curTokenIs(lexer.TokenRParen) {
  2950. return nil, p.curError("expected ) after window specification")
  2951. }
  2952. p.nextToken()
  2953. return window, nil
  2954. }
  2955. func (p *Parser) parseCaseExpr() (Expr, error) {
  2956. expr := &CaseExpr{}
  2957. p.nextToken() // consume CASE
  2958. // Check for simple CASE (CASE operand WHEN ...)
  2959. if !p.curTokenIs(lexer.TokenWHEN) {
  2960. operand, err := p.parseExpr()
  2961. if err != nil {
  2962. return nil, err
  2963. }
  2964. expr.Operand = operand
  2965. }
  2966. // Parse WHEN clauses
  2967. for p.curTokenIs(lexer.TokenWHEN) {
  2968. p.nextToken()
  2969. cond, err := p.parseExpr()
  2970. if err != nil {
  2971. return nil, err
  2972. }
  2973. if !p.curTokenIs(lexer.TokenTHEN) {
  2974. return nil, p.curError("expected THEN")
  2975. }
  2976. p.nextToken()
  2977. result, err := p.parseExpr()
  2978. if err != nil {
  2979. return nil, err
  2980. }
  2981. expr.Whens = append(expr.Whens, WhenClause{Condition: cond, Result: result})
  2982. }
  2983. // Parse optional ELSE
  2984. if p.curTokenIs(lexer.TokenELSE) {
  2985. p.nextToken()
  2986. elseExpr, err := p.parseExpr()
  2987. if err != nil {
  2988. return nil, err
  2989. }
  2990. expr.Else = elseExpr
  2991. }
  2992. // Expect END
  2993. if !p.curTokenIs(lexer.TokenEND) {
  2994. return nil, p.curError("expected END")
  2995. }
  2996. p.nextToken()
  2997. return expr, nil
  2998. }
  2999. func (p *Parser) parseCastExpr() (Expr, error) {
  3000. p.nextToken() // consume CAST
  3001. if !p.curTokenIs(lexer.TokenLParen) {
  3002. return nil, p.curError("expected (")
  3003. }
  3004. p.nextToken()
  3005. expr, err := p.parseExpr()
  3006. if err != nil {
  3007. return nil, err
  3008. }
  3009. if !p.curTokenIs(lexer.TokenAS) {
  3010. return nil, p.curError("expected AS")
  3011. }
  3012. p.nextToken()
  3013. dataType, err := p.parseDataType()
  3014. if err != nil {
  3015. return nil, err
  3016. }
  3017. if !p.curTokenIs(lexer.TokenRParen) {
  3018. return nil, p.curError("expected )")
  3019. }
  3020. p.nextToken()
  3021. return &CastExpr{Expr: expr, Type: *dataType}, nil
  3022. }
  3023. func (p *Parser) parseExistsExpr() (Expr, error) {
  3024. p.nextToken() // consume EXISTS
  3025. if !p.curTokenIs(lexer.TokenLParen) {
  3026. return nil, p.curError("expected (")
  3027. }
  3028. p.nextToken()
  3029. if !p.curTokenIs(lexer.TokenSELECT) {
  3030. return nil, p.curError("expected SELECT in EXISTS")
  3031. }
  3032. sel, err := p.parseSelect()
  3033. if err != nil {
  3034. return nil, err
  3035. }
  3036. if !p.curTokenIs(lexer.TokenRParen) {
  3037. return nil, p.curError("expected )")
  3038. }
  3039. p.nextToken()
  3040. return &ExistsExpr{Subquery: sel}, nil
  3041. }
  3042. func (p *Parser) parseExprList() ([]Expr, error) {
  3043. var exprs []Expr
  3044. for {
  3045. expr, err := p.parseExpr()
  3046. if err != nil {
  3047. return nil, err
  3048. }
  3049. exprs = append(exprs, expr)
  3050. if !p.curTokenIs(lexer.TokenComma) {
  3051. break
  3052. }
  3053. p.nextToken()
  3054. }
  3055. return exprs, nil
  3056. }
  3057. func (p *Parser) parseIdentList() ([]string, error) {
  3058. var idents []string
  3059. for {
  3060. if !p.curIsName() {
  3061. return nil, p.curError("expected identifier")
  3062. }
  3063. idents = append(idents, p.curToken.Literal)
  3064. p.nextToken()
  3065. if !p.curTokenIs(lexer.TokenComma) {
  3066. break
  3067. }
  3068. p.nextToken()
  3069. }
  3070. return idents, nil
  3071. }
  3072. // curIsName reports whether the current token can serve as a name (column or
  3073. // table identifier). A few lexer keywords, notably KEY, are commonly used as
  3074. // column names in the GoatCounter schema and SQLite allows them.
  3075. func (p *Parser) curIsName() bool {
  3076. if p.curTokenIs(lexer.TokenIdent) {
  3077. return true
  3078. }
  3079. switch p.curToken.Type {
  3080. case lexer.TokenKEY:
  3081. return true
  3082. }
  3083. return false
  3084. }
  3085. // Helper functions
  3086. func parseInt(s string) int {
  3087. var n int
  3088. for _, c := range s {
  3089. n = n*10 + int(c-'0')
  3090. }
  3091. return n
  3092. }