[{"data":1,"prerenderedAt":897},["ShallowReactive",2],{"navigation_docs_en":3,"-en-tauri-sqlite-orm-advanced-topics-raw-sql":237,"-en-tauri-sqlite-orm-advanced-topics-raw-sql-surround":892},[4,15,69,122],{"title":5,"icon":6,"path":7,"stem":8,"children":9,"page":14},"Getting Started with Docs","i-lucide-home","/en/getting-started","en/1.getting-started",[10],{"title":11,"path":12,"stem":13,"icon":6},"Introduction","/en/getting-started/introduction","en/1.getting-started/1.introduction",false,{"title":16,"path":17,"stem":18,"children":19,"page":14},"owo-ui Components","/en/owo-ui-components","en/2.owo-ui-components",[20,23],{"title":11,"path":21,"stem":22,"icon":6},"/en/owo-ui-components/introduction","en/2.owo-ui-components/2.introduction",{"title":24,"icon":25,"path":26,"stem":27,"children":28,"page":14},"Components","i-lucide-layout","/en/owo-ui-components/components","en/2.owo-ui-components/3.components",[29,33,37,41,45,49,53,57,61,65],{"title":30,"path":31,"stem":32},"Button","/en/owo-ui-components/components/button","en/2.owo-ui-components/3.components/button",{"title":34,"path":35,"stem":36},"Checkbox","/en/owo-ui-components/components/checkbox","en/2.owo-ui-components/3.components/checkbox",{"title":38,"path":39,"stem":40},"Collapsible Container","/en/owo-ui-components/components/collapsible-container","en/2.owo-ui-components/3.components/collapsible-container",{"title":42,"path":43,"stem":44},"Dropdown","/en/owo-ui-components/components/dropdown","en/2.owo-ui-components/3.components/dropdown",{"title":46,"path":47,"stem":48},"Flow Layout","/en/owo-ui-components/components/flow-layout","en/2.owo-ui-components/3.components/flow-layout",{"title":50,"path":51,"stem":52},"Grid Layout","/en/owo-ui-components/components/grid-layout","en/2.owo-ui-components/3.components/grid-layout",{"title":54,"path":55,"stem":56},"Label","/en/owo-ui-components/components/label","en/2.owo-ui-components/3.components/label",{"title":58,"path":59,"stem":60},"Scroll Container","/en/owo-ui-components/components/scroll-container","en/2.owo-ui-components/3.components/scroll-container",{"title":62,"path":63,"stem":64},"Slider","/en/owo-ui-components/components/slider","en/2.owo-ui-components/3.components/slider",{"title":66,"path":67,"stem":68},"Templates","/en/owo-ui-components/components/templates","en/2.owo-ui-components/3.components/templates",{"title":70,"path":71,"stem":72,"children":73,"page":14},"Nexus","/en/nexus","en/3.nexus",[74,77,82],{"title":11,"path":75,"stem":76,"icon":6},"/en/nexus/introduction","en/3.nexus/2.introduction",{"title":78,"path":79,"stem":80,"icon":81},"Deployment","/en/nexus/deployment","en/3.nexus/3.deployment","i-lucide-rocket",{"title":83,"path":84,"stem":85,"children":86,"page":14},"Endpoints","/en/nexus/endpoints","en/3.nexus/endpoints",[87,91,95,99,102,106,110,114,118],{"title":88,"path":89,"stem":90},"Authentication","/en/nexus/endpoints/authentication","en/3.nexus/endpoints/1.authentication",{"title":92,"path":93,"stem":94},"Rate Limiting","/en/nexus/endpoints/rate-limiting","en/3.nexus/endpoints/2.rate-limiting",{"title":96,"path":97,"stem":98},"Error Handling","/en/nexus/endpoints/error-handling","en/3.nexus/endpoints/3.error-handling",{"title":83,"path":100,"stem":101},"/en/nexus/endpoints/_dir","en/3.nexus/endpoints/_dir",{"title":103,"path":104,"stem":105},"Album","/en/nexus/endpoints/albums","en/3.nexus/endpoints/albums",{"title":107,"path":108,"stem":109},"Blog","/en/nexus/endpoints/blog","en/3.nexus/endpoints/blog",{"title":111,"path":112,"stem":113},"Comments","/en/nexus/endpoints/comments","en/3.nexus/endpoints/comments",{"title":115,"path":116,"stem":117},"File Management","/en/nexus/endpoints/file-management","en/3.nexus/endpoints/file-management",{"title":119,"path":120,"stem":121},"Photo Management","/en/nexus/endpoints/photos","en/3.nexus/endpoints/photos",{"title":123,"icon":124,"path":125,"stem":126,"children":127,"page":14},"Tauri SQLite ORM","i-lucide-database","/en/tauri-sqlite-orm","en/4.tauri-sqlite-orm",[128,132,137,141,162,187,232],{"title":11,"path":129,"stem":130,"icon":131},"/en/tauri-sqlite-orm/introduction","en/4.tauri-sqlite-orm/1.introduction","i-lucide-book-open",{"title":133,"path":134,"stem":135,"icon":136},"Installation & Setup","/en/tauri-sqlite-orm/installation-and-setup","en/4.tauri-sqlite-orm/2.installation-and-setup","i-lucide-download",{"title":138,"path":139,"stem":140,"icon":81},"Your First Schema & Query","/en/tauri-sqlite-orm/your-first-schema-and-query","en/4.tauri-sqlite-orm/3.your-first-schema-and-query",{"title":142,"path":143,"stem":144,"children":145,"page":14},"Core Concepts","/en/tauri-sqlite-orm/core-concepts","en/4.tauri-sqlite-orm/4.core-concepts",[146,150,154,158],{"title":147,"path":148,"stem":149},"Defining Schemas","/en/tauri-sqlite-orm/core-concepts/defining-schemas","en/4.tauri-sqlite-orm/4.core-concepts/1.defining-schemas",{"title":151,"path":152,"stem":153},"Column Types & Modifiers","/en/tauri-sqlite-orm/core-concepts/column-types-and-modifiers","en/4.tauri-sqlite-orm/4.core-concepts/2.column-types-and-modifiers",{"title":155,"path":156,"stem":157},"The ORM Instance","/en/tauri-sqlite-orm/core-concepts/the-orm-instance","en/4.tauri-sqlite-orm/4.core-concepts/3.the-orm-instance",{"title":159,"path":160,"stem":161},"Migrations","/en/tauri-sqlite-orm/core-concepts/migrations","en/4.tauri-sqlite-orm/4.core-concepts/4.migrations",{"title":163,"path":164,"stem":165,"children":166,"page":14},"Querying Data","/en/tauri-sqlite-orm/querying-data","en/4.tauri-sqlite-orm/5.querying-data",[167,171,175,179,183],{"title":168,"path":169,"stem":170},"Select","/en/tauri-sqlite-orm/querying-data/selecting-data","en/4.tauri-sqlite-orm/5.querying-data/1.selecting-data",{"title":172,"path":173,"stem":174},"Insert","/en/tauri-sqlite-orm/querying-data/inserting-data","en/4.tauri-sqlite-orm/5.querying-data/2.inserting-data",{"title":176,"path":177,"stem":178},"Update","/en/tauri-sqlite-orm/querying-data/updating-data","en/4.tauri-sqlite-orm/5.querying-data/3.updating-data",{"title":180,"path":181,"stem":182},"Delete","/en/tauri-sqlite-orm/querying-data/deleting-data","en/4.tauri-sqlite-orm/5.querying-data/4.deleting-data",{"title":184,"path":185,"stem":186},"Conditions & Operators","/en/tauri-sqlite-orm/querying-data/conditions-and-operators","en/4.tauri-sqlite-orm/5.querying-data/5.conditions-and-operators",{"title":188,"path":189,"stem":190,"children":191,"page":14},"Advanced Topics","/en/tauri-sqlite-orm/advanced-topics","en/4.tauri-sqlite-orm/6.advanced-topics",[192,196,200,204,208,212,216,220,224,228],{"title":193,"path":194,"stem":195},"Relations","/en/tauri-sqlite-orm/advanced-topics/working-with-relations","en/4.tauri-sqlite-orm/6.advanced-topics/1.working-with-relations",{"title":197,"path":198,"stem":199},"Error Handling & Safety","/en/tauri-sqlite-orm/advanced-topics/error-handling-and-safety","en/4.tauri-sqlite-orm/6.advanced-topics/10.error-handling-and-safety",{"title":201,"path":202,"stem":203},"Joins","/en/tauri-sqlite-orm/advanced-topics/joins","en/4.tauri-sqlite-orm/6.advanced-topics/2.joins",{"title":205,"path":206,"stem":207},"Transactions","/en/tauri-sqlite-orm/advanced-topics/transactions","en/4.tauri-sqlite-orm/6.advanced-topics/3.transactions",{"title":209,"path":210,"stem":211},"Common Table Expressions","/en/tauri-sqlite-orm/advanced-topics/common-table-expressions","en/4.tauri-sqlite-orm/6.advanced-topics/4.common-table-expressions",{"title":213,"path":214,"stem":215},"Raw SQL","/en/tauri-sqlite-orm/advanced-topics/raw-sql","en/4.tauri-sqlite-orm/6.advanced-topics/5.raw-sql",{"title":217,"path":218,"stem":219},"Type Safety & Inference","/en/tauri-sqlite-orm/advanced-topics/type-safety-and-inference","en/4.tauri-sqlite-orm/6.advanced-topics/6.type-safety-and-inference",{"title":221,"path":222,"stem":223},"Schema Management","/en/tauri-sqlite-orm/advanced-topics/manual-schema-management","en/4.tauri-sqlite-orm/6.advanced-topics/7.manual-schema-management",{"title":225,"path":226,"stem":227},"Query Debugging","/en/tauri-sqlite-orm/advanced-topics/query-debugging","en/4.tauri-sqlite-orm/6.advanced-topics/8.query-debugging",{"title":229,"path":230,"stem":231},"Subqueries & Aggregates","/en/tauri-sqlite-orm/advanced-topics/subqueries-and-aggregates","en/4.tauri-sqlite-orm/6.advanced-topics/9.subqueries-and-aggregates",{"title":233,"path":234,"stem":235,"icon":236},"API Reference","/en/tauri-sqlite-orm/api-reference","en/4.tauri-sqlite-orm/7.api-reference","i-lucide-book",{"id":238,"title":213,"body":239,"description":886,"extension":887,"links":888,"meta":889,"navigation":321,"path":214,"seo":890,"stem":215,"__hash__":891},"docs_en/en/4.tauri-sqlite-orm/6.advanced-topics/5.raw-sql.md",{"type":240,"value":241,"toc":878},"minimark",[242,246,250,258,266,271,421,424,431,440,463,624,634,641,644,861,868,874],[243,244,213],"h1",{"id":245},"raw-sql",[247,248,249],"p",{},"While the query builder aims to cover the vast majority of use cases, there will always be times when you need the power and flexibility of raw SQL—for accessing database-specific functions, performing complex calculations, or writing highly optimized queries.",[247,251,252,253,257],{},"The ORM provides a safe and convenient way to do this using the ",[254,255,256],"code",{},"sql"," template literal.",[259,260,262,263,265],"h2",{"id":261},"the-sql-template-literal","The ",[254,264,256],{}," Template Literal",[247,267,262,268,270],{},[254,269,256],{}," helper is not simple string interpolation. It's a tagged template that automatically parameterizes your values, providing a robust defense against SQL injection attacks.",[272,273,278],"pre",{"className":274,"code":275,"language":276,"meta":277,"style":277},"language-ts shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","import { sql } from '@type32/tauri-sqlite-orm';\n\n// This is SAFE. The value of `userId` will be passed as a bound parameter.\nconst condition = sql`id = ${userId}`; \n\n// This is DANGEROUS and should NEVER be done.\nconst unsafeCondition = { sql: `id = ${userId}`, params: [] };\n","ts","",[254,279,280,316,323,330,367,372,378],{"__ignoreMap":277},[281,282,285,289,293,297,300,303,306,310,313],"span",{"class":283,"line":284},"line",1,[281,286,288],{"class":287},"s7zQu","import",[281,290,292],{"class":291},"sMK4o"," {",[281,294,296],{"class":295},"sTEyZ"," sql",[281,298,299],{"class":291}," }",[281,301,302],{"class":287}," from",[281,304,305],{"class":291}," '",[281,307,309],{"class":308},"sfazB","@type32/tauri-sqlite-orm",[281,311,312],{"class":291},"'",[281,314,315],{"class":291},";\n",[281,317,319],{"class":283,"line":318},2,[281,320,322],{"emptyLinePlaceholder":321},true,"\n",[281,324,326],{"class":283,"line":325},3,[281,327,329],{"class":328},"sHwdD","// This is SAFE. The value of `userId` will be passed as a bound parameter.\n",[281,331,333,337,340,343,346,349,352,355,358,361,364],{"class":283,"line":332},4,[281,334,336],{"class":335},"spNyl","const",[281,338,339],{"class":295}," condition ",[281,341,342],{"class":291},"=",[281,344,296],{"class":345},"s2Zo4",[281,347,348],{"class":291},"`",[281,350,351],{"class":308},"id = ",[281,353,354],{"class":291},"${",[281,356,357],{"class":295},"userId",[281,359,360],{"class":291},"}`",[281,362,363],{"class":291},";",[281,365,366],{"class":295}," \n",[281,368,370],{"class":283,"line":369},5,[281,371,322],{"emptyLinePlaceholder":321},[281,373,375],{"class":283,"line":374},6,[281,376,377],{"class":328},"// This is DANGEROUS and should NEVER be done.\n",[281,379,381,383,386,388,390,393,396,399,401,403,405,407,410,413,415,418],{"class":283,"line":380},7,[281,382,336],{"class":335},[281,384,385],{"class":295}," unsafeCondition ",[281,387,342],{"class":291},[281,389,292],{"class":291},[281,391,296],{"class":392},"swJcz",[281,394,395],{"class":291},":",[281,397,398],{"class":291}," `",[281,400,351],{"class":308},[281,402,354],{"class":291},[281,404,357],{"class":295},[281,406,360],{"class":291},[281,408,409],{"class":291},",",[281,411,412],{"class":392}," params",[281,414,395],{"class":291},[281,416,417],{"class":295}," [] ",[281,419,420],{"class":291},"};\n",[247,422,423],{},"You can embed dynamic values, column objects, and even table objects directly into the template.",[259,425,427,428],{"id":426},"usage-in-where","Usage in ",[254,429,430],{},".where()",[247,432,433,434,436,437,439],{},"The most common use case for ",[254,435,256],{}," is in a ",[254,438,430],{}," clause when you need to use a function that isn't provided by the built-in operators. SQLite's JSON functions are a perfect example.",[247,441,442,443,446,447,450,451,454,455,458,459,462],{},"Let's say our ",[254,444,445],{},"users"," table has a ",[254,448,449],{},"TEXT"," column named ",[254,452,453],{},"metadata"," with ",[254,456,457],{},"{ \"mode\": \"json\" }",", where we store a JSON object. We want to find all users who have ",[254,460,461],{},"is_verified: true"," in their metadata.",[272,464,466],{"className":274,"code":465,"language":276,"meta":277,"style":277},"import { db } from '$lib/db';\nimport { users } from '$lib/db/schema';\nimport { sql } from '@type32/tauri-sqlite-orm';\n\n// Assume users.metadata is defined as: text('metadata', { mode: 'json' })\nconst verifiedUsers = await db.select(users)\n  .where(sql`json_extract(${users._.columns.metadata}, '$.is_verified') = true`)\n  .all();\n",[254,467,468,490,512,532,536,541,564,611],{"__ignoreMap":277},[281,469,470,472,474,477,479,481,483,486,488],{"class":283,"line":284},[281,471,288],{"class":287},[281,473,292],{"class":291},[281,475,476],{"class":295}," db",[281,478,299],{"class":291},[281,480,302],{"class":287},[281,482,305],{"class":291},[281,484,485],{"class":308},"$lib/db",[281,487,312],{"class":291},[281,489,315],{"class":291},[281,491,492,494,496,499,501,503,505,508,510],{"class":283,"line":318},[281,493,288],{"class":287},[281,495,292],{"class":291},[281,497,498],{"class":295}," users",[281,500,299],{"class":291},[281,502,302],{"class":287},[281,504,305],{"class":291},[281,506,507],{"class":308},"$lib/db/schema",[281,509,312],{"class":291},[281,511,315],{"class":291},[281,513,514,516,518,520,522,524,526,528,530],{"class":283,"line":325},[281,515,288],{"class":287},[281,517,292],{"class":291},[281,519,296],{"class":295},[281,521,299],{"class":291},[281,523,302],{"class":287},[281,525,305],{"class":291},[281,527,309],{"class":308},[281,529,312],{"class":291},[281,531,315],{"class":291},[281,533,534],{"class":283,"line":332},[281,535,322],{"emptyLinePlaceholder":321},[281,537,538],{"class":283,"line":369},[281,539,540],{"class":328},"// Assume users.metadata is defined as: text('metadata', { mode: 'json' })\n",[281,542,543,545,548,550,553,555,558,561],{"class":283,"line":374},[281,544,336],{"class":335},[281,546,547],{"class":295}," verifiedUsers ",[281,549,342],{"class":291},[281,551,552],{"class":287}," await",[281,554,476],{"class":295},[281,556,557],{"class":291},".",[281,559,560],{"class":345},"select",[281,562,563],{"class":295},"(users)\n",[281,565,566,569,572,575,577,579,582,584,586,588,591,593,596,598,600,603,606,608],{"class":283,"line":380},[281,567,568],{"class":291},"  .",[281,570,571],{"class":345},"where",[281,573,574],{"class":295},"(",[281,576,256],{"class":345},[281,578,348],{"class":291},[281,580,581],{"class":308},"json_extract(",[281,583,354],{"class":291},[281,585,445],{"class":295},[281,587,557],{"class":291},[281,589,590],{"class":295},"_",[281,592,557],{"class":291},[281,594,595],{"class":295},"columns",[281,597,557],{"class":291},[281,599,453],{"class":295},[281,601,602],{"class":291},"}",[281,604,605],{"class":308},", '$.is_verified') = true",[281,607,348],{"class":291},[281,609,610],{"class":295},")\n",[281,612,614,616,619,622],{"class":283,"line":613},8,[281,615,568],{"class":291},[281,617,618],{"class":345},"all",[281,620,621],{"class":295},"()",[281,623,315],{"class":291},[247,625,626,627,630,631,633],{},"The ORM correctly substitutes ",[254,628,629],{},"users.metadata"," with the actual column name (",[254,632,453],{},"), resulting in a safe and valid query.",[259,635,427,637,640],{"id":636},"usage-in-set-for-atomic-updates",[254,638,639],{},".set()"," for Atomic Updates",[247,642,643],{},"Another powerful use is performing atomic updates directly in the database, avoiding race conditions that can occur with a \"read-then-write\" approach.",[272,645,647],{"className":274,"code":646,"language":276,"meta":277,"style":277},"// Atomically increment a user's login count\n// Note: You can now use the .increment() helper instead!\nawait db.update(users)\n  .increment('loginCount')\n  .where(eq(users._.columns.id, 1))\n  .execute();\n\n// Or use raw SQL for more complex updates\nawait db.update(users)\n  .set({ \n    loginCount: sql`${users._.columns.loginCount} + 1` \n  })\n  .where(eq(users._.columns.id, 1))\n  .execute();\n",[254,648,649,654,659,673,691,727,738,742,747,760,775,811,819,850],{"__ignoreMap":277},[281,650,651],{"class":283,"line":284},[281,652,653],{"class":328},"// Atomically increment a user's login count\n",[281,655,656],{"class":283,"line":318},[281,657,658],{"class":328},"// Note: You can now use the .increment() helper instead!\n",[281,660,661,664,666,668,671],{"class":283,"line":325},[281,662,663],{"class":287},"await",[281,665,476],{"class":295},[281,667,557],{"class":291},[281,669,670],{"class":345},"update",[281,672,563],{"class":295},[281,674,675,677,680,682,684,687,689],{"class":283,"line":332},[281,676,568],{"class":291},[281,678,679],{"class":345},"increment",[281,681,574],{"class":295},[281,683,312],{"class":291},[281,685,686],{"class":308},"loginCount",[281,688,312],{"class":291},[281,690,610],{"class":295},[281,692,693,695,697,699,702,705,707,709,711,713,715,718,720,724],{"class":283,"line":369},[281,694,568],{"class":291},[281,696,571],{"class":345},[281,698,574],{"class":295},[281,700,701],{"class":345},"eq",[281,703,704],{"class":295},"(users",[281,706,557],{"class":291},[281,708,590],{"class":295},[281,710,557],{"class":291},[281,712,595],{"class":295},[281,714,557],{"class":291},[281,716,717],{"class":295},"id",[281,719,409],{"class":291},[281,721,723],{"class":722},"sbssI"," 1",[281,725,726],{"class":295},"))\n",[281,728,729,731,734,736],{"class":283,"line":374},[281,730,568],{"class":291},[281,732,733],{"class":345},"execute",[281,735,621],{"class":295},[281,737,315],{"class":291},[281,739,740],{"class":283,"line":380},[281,741,322],{"emptyLinePlaceholder":321},[281,743,744],{"class":283,"line":613},[281,745,746],{"class":328},"// Or use raw SQL for more complex updates\n",[281,748,750,752,754,756,758],{"class":283,"line":749},9,[281,751,663],{"class":287},[281,753,476],{"class":295},[281,755,557],{"class":291},[281,757,670],{"class":345},[281,759,563],{"class":295},[281,761,763,765,768,770,773],{"class":283,"line":762},10,[281,764,568],{"class":291},[281,766,767],{"class":345},"set",[281,769,574],{"class":295},[281,771,772],{"class":291},"{",[281,774,366],{"class":295},[281,776,778,781,783,785,788,790,792,794,796,798,800,802,804,807,809],{"class":283,"line":777},11,[281,779,780],{"class":392},"    loginCount",[281,782,395],{"class":291},[281,784,296],{"class":345},[281,786,787],{"class":291},"`${",[281,789,445],{"class":295},[281,791,557],{"class":291},[281,793,590],{"class":295},[281,795,557],{"class":291},[281,797,595],{"class":295},[281,799,557],{"class":291},[281,801,686],{"class":295},[281,803,602],{"class":291},[281,805,806],{"class":308}," + 1",[281,808,348],{"class":291},[281,810,366],{"class":295},[281,812,814,817],{"class":283,"line":813},12,[281,815,816],{"class":291},"  }",[281,818,610],{"class":295},[281,820,822,824,826,828,830,832,834,836,838,840,842,844,846,848],{"class":283,"line":821},13,[281,823,568],{"class":291},[281,825,571],{"class":345},[281,827,574],{"class":295},[281,829,701],{"class":345},[281,831,704],{"class":295},[281,833,557],{"class":291},[281,835,590],{"class":295},[281,837,557],{"class":291},[281,839,595],{"class":295},[281,841,557],{"class":291},[281,843,717],{"class":295},[281,845,409],{"class":291},[281,847,723],{"class":722},[281,849,726],{"class":295},[281,851,853,855,857,859],{"class":283,"line":852},14,[281,854,568],{"class":291},[281,856,733],{"class":345},[281,858,621],{"class":295},[281,860,315],{"class":291},[247,862,863,864,867],{},"This sends a single ",[254,865,866],{},"UPDATE users SET login_count = login_count + 1 WHERE id = ?"," query, ensuring the operation is safe even with concurrent requests.",[247,869,870,871,873],{},"While ",[254,872,256],{}," is a powerful escape hatch, you should always prefer the built-in query builders and operators when possible. They provide stronger type safety and are often more readable for common operations.",[875,876,877],"style",{},"html pre.shiki code .s7zQu, html code.shiki .s7zQu{--shiki-light:#39ADB5;--shiki-light-font-style:italic;--shiki-default:#89DDFF;--shiki-default-font-style:italic;--shiki-dark:#89DDFF;--shiki-dark-font-style:italic}html pre.shiki code .sMK4o, html code.shiki .sMK4o{--shiki-light:#39ADB5;--shiki-default:#89DDFF;--shiki-dark:#89DDFF}html pre.shiki code .sTEyZ, html code.shiki .sTEyZ{--shiki-light:#90A4AE;--shiki-default:#EEFFFF;--shiki-dark:#BABED8}html pre.shiki code .sfazB, html code.shiki .sfazB{--shiki-light:#91B859;--shiki-default:#C3E88D;--shiki-dark:#C3E88D}html pre.shiki code .sHwdD, html code.shiki .sHwdD{--shiki-light:#90A4AE;--shiki-light-font-style:italic;--shiki-default:#546E7A;--shiki-default-font-style:italic;--shiki-dark:#676E95;--shiki-dark-font-style:italic}html pre.shiki code .spNyl, html code.shiki .spNyl{--shiki-light:#9C3EDA;--shiki-default:#C792EA;--shiki-dark:#C792EA}html pre.shiki code .s2Zo4, html code.shiki .s2Zo4{--shiki-light:#6182B8;--shiki-default:#82AAFF;--shiki-dark:#82AAFF}html pre.shiki code .swJcz, html code.shiki .swJcz{--shiki-light:#E53935;--shiki-default:#F07178;--shiki-dark:#F07178}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sbssI, html code.shiki .sbssI{--shiki-light:#F76D47;--shiki-default:#F78C6C;--shiki-dark:#F78C6C}",{"title":277,"searchDepth":318,"depth":318,"links":879},[880,882,884],{"id":261,"depth":318,"text":881},"The sql Template Literal",{"id":426,"depth":318,"text":883},"Usage in .where()",{"id":636,"depth":318,"text":885},"Usage in .set() for Atomic Updates","Raw SQL in Tauri SQLite ORM.","md",null,{},{"title":213,"description":886},"m6RGJhv-WyeQt1g3rvZ2U7WFkXmZx5etk45l4IoVZIo",[893,895],{"title":209,"path":210,"stem":211,"description":894,"children":-1},"CTEs in Tauri SQLite ORM.",{"title":217,"path":218,"stem":219,"description":896,"children":-1},"Type Safety & Inference in Tauri SQLite ORM.",1773317304356]