8 ms·

SQLite Date and Time Functions (2007)

• vadivlkumar 1y ago
  [dead]
• needusername 1y ago
  Ignoring time zones, the Boris Johnson approach to time zones.
• biofuel5 1y ago
  I just store millis or nanos as INTEGER. Never found the correct use for string datetimes, also they're slower and take much more space
  • simonw 1y ago
    The main advantage of string datetimes is that you can decipher what they mean just by looking at them in a table.
    • o11c 1y ago
      Just CREATE VIEW something (ahead of time, so it's ready) for the rare time you need to visually inspect it.
  • bob1029 1y ago
    This is the best path in my experience. I typically store timestamps as 64-bit unix seconds in the same way. On the application side, I use Dapper and DateTimeOffset to map these to a domain type with proper DateTime/UTC fields. I've found that storing time as integers in the database has some interesting upsides. For example, range queries over the field tend to be faster.
  • crazygringo 1y ago
    For storing actual moments in physical time (especially past events), and where the time zone is irrelevant, for sure. But for storing future events that are tied to a time zone, you need the string with time zone. Otherwise when time zone definitions change, your time will become wrong.
    • hudsonja 1y ago
      Timezones just give you a set of rules to determine a cultural description of a given point in time. How is timezone any more or less relevant to a future vs. past event?
      • jbverschoor 1y ago
        Timezones can change.
        • SoftTalker 1y ago
          Units of time can also change. It's possible that a day of 10 hours of 100 minutes could be legislated. Not likely, but possible.
          • netsharc 1y ago
            This isn't a very good rebuttal, because one of these things (timezone change) happens quite frequently and the other (changes to units of time) hasn't happened in any noticable scale.
      • pgwhalen 1y ago
        The cultural rules tend to be more important when describing future events, where the “human friendly” description is what really defines it. When describing past events, it’s often most precise to describe the literal universe time that it happened. Obviously these are just generalities, whether you choose one strategy or another depends on the specific use case.
      • crazygringo 1y ago
        As I said, because time zone definitions change. If daylight savings time gets cancelled by legislation, then the event happening at noon two summers from now, you will still probably want to happen at noon -- the new noon. But changes to timezones don't apply retroactively. At least not in this universe!
    • 1y ago
  • rini17 1y ago
    If users expect functionality for filtering by year or year-month, having indexed string date/time makes implementation trivial.
• deleted 1y ago
  [deleted]
• stillpointlab 1y ago
  The fact that they do not include the trailing 'Z' for UTC timestamps is a frustration for me. It caused a few hours of debugging since JavaScript date parsing assumes that dates that lack the trailing Z are in the client time zone. I had to add a hack to check if a UTC date did or did not have the trailing Z and append the Z if it was missing. This is made worse when you have a lot of `createdAt` columns that get set to NOW. You have to deal with the missing Z in all places where it matters. And in general, it is pointless to use the `localtime` parameter since that is the server time, and for UI I want to display the time local for the user. So I want to deal exclusively in UTC on the server and do any time zone conversions on the client. Worth noting that when I changed to PostgreSQL, its date function does add the Z which makes life easier in general. But it is an inconsistency to be aware of if you use both DBs.
  • noitpmeder 1y ago
    Seems it should be trivial to extend/change the data type to add a Z. It's not like it's storing the ISO8601 string in the db itself, so it's just a presentation later that is giving you the string.
    • em500 1y ago
      You don't actually know how they're stored. SQLite has a rather idiosyncratic approach to datetimes: it does not provide any datetime data types (the only SQLite data types are NULL, INTEGER, REAL, TEXT and BLOB). It's left entirely to the user how to store datetimes using these types. What SQLite does provide are functions (documented on the submitted page) that translate some datetime representations (stored using the one of the mentioned basic datatypes) to other formats. So you can choose to store your datetimes in unix-epoch INTEGER and use the translation functions to output ISO8601 TEXT when needed, or the other way around: there is no correct or even preferred way in SQLite.
      • chasil 1y ago
        You have two choices. UNIX epoch time is defined as the number of seconds since 1970/1/1 midnight. You can do those. I think there is also Julian time, which incorporates the Gregorian skip. It is stored as a floating point number, the integer portion being the day, and the fractional part being the hour.
• ncruces 1y ago
  Why not link to the most recent version? https://sqlite.org/lang_datefunc.html https://sqlite.org/lang_datefunc.html
• SJC_Hacker 1y ago
  They probably should have just omitted date/time functionality completely, keeping in spirit the "Lite" in SQLite. Their implementation is so bare bones as to be nearly useless compared to say PostgreSQL. Users could then just use either client or user created functions to do the conversion, in whatever makes sense for the app. If all you need is GMT, just store seconds/milliseconds etc. from epoch. If you want to store older dates like in a historical database, strings or day/month/year split or even just single integer. Name columns appropriately to avoid ambiguity, like "gmt_ms" and it shouldn't cause too many problems.
  • dardeaup 1y ago
    I disagree. I think that date/time data is pervasive enough to even warrant having built-in column data types for them. It's helpful when you care about data integrity.
  • aldonius 1y ago
    There's just enough there to be able to do "+1 month" calculations and similar, which is really helpful for generating dates in a range.
• DecoPerson 1y ago
  One huge benefit of using SQLite over a traditional server/client DBMS is the ability to easily add SQL functions that call into your host language and memory-space. For example, we’re using better-sqlite3 which has a convenient API for adding SQL functions [1], and we have dozens of helper methods for dealing with time using the temporal-polyfill module. We have custom JSON-based serialisation formats for PlainDate, PlainTime, PlainDateTime, ZonedDateTome, etc. Then in SQL we can call ‘isDate_Between__(a, b, c)`. a, b, and c are deserialised by the JS (TS) function, the logic is run, and the result is returned to SQLite. We’ve had no performance issues with this approach, though we’re only dealing with simple CRUD stuff. No big data. You can even use these functions with generated columns and indexes, but I haven’t found a proper use for this yet in my work. [1] https://github.com/WiseLibs/better-sqlite3/blob/HEAD/docs/api.md#functionname-options-function---this https://github.com/WiseLibs/better-sqlite3/blob/HEAD/docs/ap...
  • Leherenn 1y ago
    We do this as well, but the main drawback is that your DB is "unusable" without those functions, and the functions are application side only. So if you get a DB from somewhere else and want to open it in whatever tool you use for visualisation, all the queries/views/... will not work because they don't know about all those functions.
• somat 1y ago
  sqlite is pretty great, but I have to admit the main reason I keep using postgres, even in situations where sqlite would probably be a better fit, is that I like the postgres standard function library better. But I also use postgres as a sort of better excel, so what do I know. My desktop instance has a million silly small tables, you know back of envelope ideas, exploratory data, to do lists, etc
• 1vuio0pswjnm7 1y ago
  The speed of sqlite3 is good Something like echo "select datetime(time,'unixepoch'),id from t1"|sqlite3 0.db Sometimes I need to convert dates in text files to or from unixepoch^1 IME, this is at least 2x as slow as converting dates with sqlite3 For example, I have a text file with the following format domainname ipv4-address # unixepoch I use a simple filter something like this ("yy094") /* strftime<-->strptime */ int fileno (FILE *); FILE *f; #define jmp (yy_start)=1+2* #include <time.h> char *strptime(const char *s, const char *f, struct tm *tm); struct tm t; typedef long int time_t; time_t xt; char zt[26]; struct tm *yt; a Mon|Tue|Wed|Thu|Fri|Sat|Sun d (0[1-9]|[12][0-9]|3[01]) b Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec m 0[1-9]|1[012] Y 19[2-9][0-9]|[2-9][0-9]{3} H [0-9]{2} M [0-9]{2} S [0-9]{2} Z [+-][0-9]{2,4}|[A-EG-KMNPSTUWZh]{2,3}[CTAK] int xd70f5083A() { printf("%ld",mktime(&t)); return 0; } int x2146ea7d() { xt=atoi(yytext); if((xt<-2147483646)||(xt>2147483648)) {fwrite(yytext,1,yyleng,yyout);goto s;} yt=localtime(&xt); strftime(zt,sizeof(zt),"%d %b %Y %H:%M:%S %Z",yt); fwrite(zt,sizeof(zt),1,stdout); return 0; s:return 1; } %option nounput noinput noyywrap %% [12][0-9]{9} { x2146ea7d(); } {d}[ ]{b}[ ]{Y}[ ]{H}:{M}:{S}[ ]{Z} { strptime(yytext,"%d %b %Y %H:%M:%S %Z",&t); xd70f5083A(); } {d}[ ]{b}[ ]{Y}[ ]{H}:{M}:{S} { strptime(yytext,"%d %b %Y %H:%M:%S",&t); xd70f5083A(); } {a}[ ]{b}[ ]{d}[ ]{H}:{M}:{S}[ ]UTC[ ]{Y} { strptime(yytext,"%a %b %d %H:%M:%S UTC %Y",&t); xd70f5083A(); } {Y}-{m}-{d}T{H}:{M}:{S} { strptime(yytext,"%Y-%m-%dT%H:%M:%S",&t); xd70f5083A(); } {Y}-{m}-{d}[ ]{H}:{M}:{S} { strptime(yytext,"%Y-%m-%d %H:%M:%S",&t); xd70f5083A(); } .|\n+ fwrite(yytext,1,yyleng,yyout); %% int main(int argc, char *argv[]) { if(argc>1)if(argv[1]) if(argv[1][0]==45) if(argv[1][1]==104) { putc(10,stdout); puts(" usage: yy094 < file"); puts(" zones: UTC only"); puts(" range: 09 Sep 2001 01:46:40 - 19 Jan 2038 03:14:07"); puts(" input formats:"); puts(" 2147483647"); puts(" 09 Sep 2001 01:46:40"); puts(" 09 Sep 2001 01:46:40 UTC"); puts(" 2001 Sep 09 01:46:40"); puts(" 2001-Sep-09T01:46:40"); puts(" 09 Sep 2001 01:46:40 UTC"); puts(" Sun Sep 09 01:46:40 UTC 2001"); puts(" output formats:"); puts(" 19 Jan 2038 03:14:07 UTC"); putc(10,stdout); goto x; } yylex(); x:exit(0); }
  • 1vuio0pswjnm7 1y ago