SQLite functions: unistr and unistr_quote

Tue, 26 Aug 2025 00:00:00 UTC

SQLite [3.50](https://www.sqlite.org/releaselog/3_50_0.html) introduced [unistr](https://www.sqlite.org/lang_corefunc.html#unistr) and [unistr_quote](https://www.sqlite.org/lang_corefunc.html#unistr_quote) functions These are for taking in escape sequences and returning the actual unicode string like emoji or other non-english characters outside the ascii convention forming the utf-8 character set The `unistr` is used to take in the escape sequences and return the actual unicode string The `unistr_quote` is used to escape those escape sequences in a sql query so your data can be stored with emojis. > I wonder these functions were added because of LLMs emoji-heavy outputs? Here’s how you use unistr in a simple query ```sql SELECT unistr('\u2665, \U0001F600'); ```` This will print the :heart and :smiley emojis I won’t print the emojis, it might look like a AI-generated post (grunts with pride) This is handy to render the values but first you need to get the values stored in the db, for that you need to have it like a string i.e. escaped string That is where the `unistr_quote comes` in ```sql SELECT unistr_quote('\U0001F600'); ``` This will simply print '\U0001F600' notice the quotes here, it will be a escaped character sequence making it like a special string in middle of a string, so if we have something like this ```sql SELECT printf('what the heck is this%s symbol?', unistr_quote('\U0001F449')); ``` > output: what the heck is this'\U0001F449' symbol? This will make the distinction clear, we get a quoted string for that special set of characters or escape sequence which can be useful if the storage medium would make storing emojis obsolete.

SQLite functions: Generate_Series Examples

Fri, 22 Aug 2025 00:00:00 UTC

After taking a look at what the Generate Series function does, now let's see some examples that might be handy. ## Simple sequence To generate a series of numbers from 1 to 5. ```sql SELECT * FROM generate_series(1, 5); ``` ## Incremental sequence To generate a series of numbers from 0 to 50 in steps of 10. ```sql SELECT * FROM generate_series(0, 50, 10); ``` This will start from 0, increment by 10 till 50. ``` 0 10 20 30 40 50 ``` ## Backwards sequence To generate a series from 50 to 0 in steps of 10 ```sql SELECT * FROM generate_series(0, 50, -10); ``` This would start from 50 (becuase -ve step will flip the start and stop parameters) and decrement by 10 till 0 ``` 50 40 30 20 10 0 ``` ## Random Numbers To generate 5 random number between 1 to 5. ```sql SELECT * FROM generate_series(1, 5) ORDER BY RANDOM(); ``` This would generate 5 numbers 1 to 5, and the ordering will be random. This is becuase for each row, it will generate a random number between -max int to +max int and then order them based on those numbers. OR To generate 5 random number between 1 and 10. ``` SELECT ABS((random()%10)) + 1 FROM generate_series(1, 5); ``` This would generate 5 random numbers between 1 and 10. The random function generates a integer between -max int to +max int and then mod it to 10 (or the range you want to generate up to) this will leave us with -9 to 9 numbers but it also be negative so we make it ABS which will make it positive, and add one to make the 0 offset to 1. ``` 3 9 10 7 5 ``` ## Random Characters To generate 5 random characters from A to Z. ```sql SELECT char((random()%26)+65) FROM generate_series(1, 5); ``` This would generate a random integer between -max int and + max int, mod it with 26 to get that number between 0 to 25, add 65 which will then can be casted to char in order to render it as an ASCII String. ## Date Ranges To generate dates for a month ```sql SELECT date('2025-08-01', '+' || (value-1) || ' day') as date_val FROM generate_series(1, 31); ``` This will take the start date 2025-08-01 and add the value -1 (the value will be from 1 so we need to omit the first day) as a day. This will then generate a series of dates from 2025-08-01 to 2025-08-31. To generate first day of each month ```sql SELECT date('2025-08-01', '+' || (value-1) || ' month') as date_val FROM generate_series(1, 12); ``` ## Gap filling in existing ids To fill in the missing ids in a sequence of ids ```sql SELECT * FROM generate_series(1, 5) WHERE value NOT IN (1, 3, 5); ``` Here you could imagine the not in list could be another table with the result set only with the ids.

SQLite functions: generate_series

Thu, 21 Aug 2025 00:00:00 UTC

The [generate_series](https://www.sqlite.org/series.html) is a table valued function in sqlite and is available via the [generate_series](https://sqlite.org/src/artifact?ci=trunk&filename=ext/misc/series.c) extension. > The valued function is something that returns a table but is virtual (doesn't really have data or schema in it). It has hidden columns which are used as parameters to the function to constrain the output and generate the data according to those parameters to the function. The basic operation with `generate_series` would look like this: ```sql SELECT * FROM generate_series(1, 5); ``` ``` sqlite> SELECT * FROM generate_series(1, 5); +-------+ | value | +-------+ | 1 | | 2 | | 3 | | 4 | | 5 | +-------+ sqlite> ``` Pretty neat, it generated a series of numbers (integers) from 1 to 5 (5 included). Now are they really integers or? SQLite is wired, it doesn't really have types, but they are integers as default so to confirm: ```sql SELECT typeof(value) FROM generate_series(1, 5); ``` ``` sqlite> SELECT typeof(value) FROM generate_series(1, 5); +---------------+ | typeof(value) | +---------------+ | integer | | integer | | integer | | integer | | integer | +---------------+ ``` OK! Cool, now let's take this to a next level ```sql SELECT char(value+64) FROM generate_series(1, 5); ``` ``` sqlite> SELECT char(value+64) FROM generate_series(1, 5); +----------------+ | char(value+64) | +----------------+ | A | | B | | C | | D | | E | +----------------+ ``` OK! That is simple ascii and type casting shenanigans! We cast the value which would be integer 1 to 5 and add 64 to it to make it in the range 65 to 70 which would be ASCII equivalent of A to E, you could do the same thing but different parameters: ``` SELECT char(value) FROM generate_series(65, 70); ``` ``` sqlite> SELECT char(value) FROM generate_series(65, 70); +-------------+ | char(value) | +-------------+ | A | | B | | C | | D | | E | | F | +-------------+ ``` Same result! But, ok, this is other rabbit hole, let's focus back on generate_series, the parameters are start and stop right? Well there is one more, step. This will be like the incremental number for each step. If you are familiar with C styled for loops, you know this as the increment part, or the `i++` bit. ```sql SELECT value FROM generate_series(0, 20, 5) ``` ``` sqlite> SELECT value FROM generate_series(0, 20, 5); +-------+ | value | +-------+ | 0 | | 5 | | 10 | | 15 | | 20 | +-------+ sqlite> ``` So, the third parameter increments the counter by that number. So we start from 0 and increment 5 for each step (row) till 20. Default step value is 1, however the quirk is 0 is still considered as 1. You can also go reverse ```sql SELECT * FROM generate_series(0, 20, -5); ``` This will generate number series as 20,15,10,5,0: Note that the step is -1 not the stop value, this will basically flip the start and stop values, so we will start from 20 and decrement by 5 at each step. If you want to generate a series in negative ranges, the start or stop needs to modified accordingly, the start and stop control which numbers you iterate and the step controls in which direction it moves from start to end. ```sql SELECT * FROM generate_series(-20, 20, -5); ``` This will generate the number series from 20 to -20, start from 20 and decrement by 5 each step until we reach -20. So we had a start as -20 but why do we start from 20? well because the step is negative, we need to start from the higher value and end at the lower value, hence the start and stop will be flipped for a step value < 0. ```sql SELECT * FROM generate_series(10) LIMIT 5; ``` This gave 10,11,12,13,14 right, how? Because there is not just one column in the generate_series virtual table there are more Apart from value that is the integer we get from the function as the row (column cell) there are start, stop, step and rowid columns which are hidden columns in the `generate_series` function or virtual table Let’s see SELECT rowid, start, stop, step, value FROM generate_series(0,10,2); ``` +-------+-------+------+------+-------+ | rowid | start | stop | step | value | +-------+-------+------+------+-------+ | 1 | 0 | 10 | 2 | 0 | | 2 | 0 | 10 | 2 | 2 | | 3 | 0 | 10 | 2 | 4 | | 4 | 0 | 10 | 2 | 6 | | 5 | 0 | 10 | 2 | 8 | | 6 | 0 | 10 | 2 | 10 | +-------+-------+------+------+-------+ ``` The start, stop, step values remain same, as those are the parameters those can’t change but notice the rowid and the value the first and the last column in the result set do change. Interestingly the start, stop, and step are the parameters to the function, so you can technically pass them however you like ```sql SELECT * FROM generate_series() WHERE start = 10 AND stop = 20 AND step = 5; ``` This will give 10,15,20 since the start is 10, increment by 5 until 20. The step is optional, note that stop is optional too, but never forget to provide it, it might cause a forever loop and keep on incrementing by 1 and never give the result back until your computer crashes.

Understanding Go's Weak Package

Thu, 02 Jan 2025 00:00:00 UTC

Go's weak package provides weak references for garbage collection.

MindsDB GraphQL API (Grafbase)

Sun, 13 Aug 2023 00:00:00 UTC

A GraphQL API for MindsDB using Grafbase that allows you to interact with MindsDB databases, projects, models, and more through a GraphQL interface. Tech Stack: - Typescript - Grafbase - GraphQL

Utility-Studio

Fri, 14 Jul 2023 00:00:00 UTC

A application to perform extraction of information from web, youtube, or document links, download video/audio from youtube links, and summarize the text content. Tech Stack: - Refine (React, NextJS) - Appwrite (Functions, Storage) - Typescript - Python (Cloud Functions) - Material UI

Meet Gor - Tag: typescript