sqlcipher/src/date.c at sqlite-release · sqlcipher/sqlcipher · GitHub

History

1828 lines (1765 loc) · 48.4 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

** 2003 October 31

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

*************************************************************************

** This file contains the C functions that implement date and time

** functions for SQLite.

** There is only one exported symbol in this file - the function

** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.

** All other code has file scope.

** SQLite processes all times and dates as julian day numbers. The

** dates and times are stored as the number of days since noon

** in Greenwich on November 24, 4714 B.C. according to the Gregorian

** calendar system.

** 1970-01-01 00:00:00 is JD 2440587.5

** 2000-01-01 00:00:00 is JD 2451544.5

** This implementation requires years to be expressed as a 4-digit number

** which means that only dates between 0000-01-01 and 9999-12-31 can

** be represented, even though julian day numbers allow a much wider

** range of dates.

** The Gregorian calendar system is used for all dates and times,

** even those that predate the Gregorian calendar. Historians usually

** use the julian calendar for dates prior to 1582-10-15 and for some

** dates afterwards, depending on locale. Beware of this difference.

** The conversion algorithms are implemented based on descriptions

** in the following text:

** Jean Meeus

** Astronomical Algorithms, 2nd Edition, 1998

** ISBN 0-943396-61-1

** Willmann-Bell, Inc

** Richmond, Virginia (USA)

#include "sqliteInt.h"

#include <stdlib.h>

#include <assert.h>

#include <time.h>

#ifndef SQLITE_OMIT_DATETIME_FUNCS

** The MSVC CRT on Windows CE may not have a localtime() function.

** So declare a substitute. The substitute function itself is

** defined in "os_win.c".

#if !defined(SQLITE_OMIT_LOCALTIME) && defined(_WIN32_WCE) && \

(!defined(SQLITE_MSVC_LOCALTIME_API) || !SQLITE_MSVC_LOCALTIME_API)

struct tm *__cdecl localtime(const time_t *);

#endif

** A structure for holding a single date and time.

typedef struct DateTime DateTime;

struct DateTime {

sqlite3_int64 iJD; /* The julian day number times 86400000 */

int Y, M, D; /* Year, month, and day */

int h, m; /* Hour and minutes */

int tz; /* Timezone offset in minutes */

double s; /* Seconds */

char validJD; /* True (1) if iJD is valid */

char validYMD; /* True (1) if Y,M,D are valid */

char validHMS; /* True (1) if h,m,s are valid */

char nFloor; /* Days to implement "floor" */

unsigned rawS : 1; /* Raw numeric value stored in s */

unsigned isError : 1; /* An overflow has occurred */

unsigned useSubsec : 1; /* Display subsecond precision */

unsigned isUtc : 1; /* Time is known to be UTC */

unsigned isLocal : 1; /* Time is known to be localtime */

};

** Convert zDate into one or more integers according to the conversion

** specifier zFormat.

** zFormat[] contains 4 characters for each integer converted, except for

** the last integer which is specified by three characters. The meaning

** of a four-character format specifiers ABCD is:

** A: number of digits to convert. Always "2" or "4".

** B: minimum value. Always "0" or "1".

** C: maximum value, decoded as:

** a: 12

** b: 14

** c: 24

** d: 31

** e: 59

** f: 9999

** D: the separator character, or \000 to indicate this is the

** last number to convert.

** Example: To translate an ISO-8601 date YYYY-MM-DD, the format would

** be "40f-21a-20c". The "40f-" indicates the 4-digit year followed by "-".

** The "21a-" indicates the 2-digit month followed by "-". The "20c" indicates

** the 2-digit day which is the last integer in the set.

** The function returns the number of successful conversions.

static int getDigits(const char *zDate, const char *zFormat, ...){

/* The aMx[] array translates the 3rd character of each format

** spec into a max size: a b c d e f */

static const u16 aMx[] = { 12, 14, 24, 31, 59, 14712 };

va_list ap;

int cnt = 0;

char nextC;

va_start(ap, zFormat);

do{

char N = zFormat[0] - '0';

char min = zFormat[1] - '0';

int val = 0;

u16 max;

assert( zFormat[2]>='a' && zFormat[2]<='f' );

max = aMx[zFormat[2] - 'a'];

nextC = zFormat[3];

val = 0;

while( N-- ){

if( !sqlite3Isdigit(*zDate) ){

goto end_getDigits;

}

val = val*10 + *zDate - '0';

zDate++;

}

if( val<(int)min || val>(int)max || (nextC!=0 && nextC!=*zDate) ){

goto end_getDigits;

}

*va_arg(ap,int*) = val;

zDate++;

cnt++;

zFormat += 4;

}while( nextC );

end_getDigits:

va_end(ap);

return cnt;

}

** Parse a timezone extension on the end of a date-time.

** The extension is of the form:

** (+/-)HH:MM

** Or the "zulu" notation:

** Z

** If the parse is successful, write the number of minutes

** of change in p->tz and return 0. If a parser error occurs,

** return non-zero.

** A missing specifier is not considered an error.

static int parseTimezone(const char *zDate, DateTime *p){

int sgn = 0;

int nHr, nMn;

int c;

while( sqlite3Isspace(*zDate) ){ zDate++; }

p->tz = 0;

c = *zDate;

if( c=='-' ){

sgn = -1;

}else if( c=='+' ){

sgn = +1;

}else if( c=='Z' || c=='z' ){

zDate++;

p->isLocal = 0;

p->isUtc = 1;

goto zulu_time;

}else{

return c!=0;

}

zDate++;

if( getDigits(zDate, "20b:20e", &nHr, &nMn)!=2 ){

return 1;

}

zDate += 5;

p->tz = sgn*(nMn + nHr*60);

if( p->tz==0 ){ /* Forum post 2025-09-17T10:12:14z */

p->isLocal = 0;

p->isUtc = 1;

}

zulu_time:

while( sqlite3Isspace(*zDate) ){ zDate++; }

return *zDate!=0;

}

** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF.

** The HH, MM, and SS must each be exactly 2 digits. The

** fractional seconds FFFF can be one or more digits.

** Return 1 if there is a parsing error and 0 on success.

static int parseHhMmSs(const char *zDate, DateTime *p){

int h, m, s;

double ms = 0.0;

if( getDigits(zDate, "20c:20e", &h, &m)!=2 ){

return 1;

}

zDate += 5;

if( *zDate==':' ){

zDate++;

if( getDigits(zDate, "20e", &s)!=1 ){

return 1;

}

zDate += 2;

if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){

double rScale = 1.0;

zDate++;

while( sqlite3Isdigit(*zDate) ){

ms = ms*10.0 + *zDate - '0';

rScale *= 10.0;

zDate++;

}

ms /= rScale;

/* Truncate to avoid problems with sub-milliseconds

** rounding. https://sqlite.org/forum/forumpost/766a2c9231 */

if( ms>0.999 ) ms = 0.999;

}

}else{

s = 0;

}

p->validJD = 0;

p->rawS = 0;

p->validHMS = 1;

p->h = h;

p->m = m;

p->s = s + ms;

if( parseTimezone(zDate, p) ) return 1;

return 0;

}

** Put the DateTime object into its error state.

static void datetimeError(DateTime *p){

memset(p, 0, sizeof(*p));

p->isError = 1;

}

** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume

** that the YYYY-MM-DD is according to the Gregorian calendar.

** Reference: Meeus page 61

static void computeJD(DateTime *p){

int Y, M, D, A, B, X1, X2;

if( p->validJD ) return;

if( p->validYMD ){

Y = p->Y;

M = p->M;

D = p->D;

}else{

Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */

M = 1;

D = 1;

}

if( Y<-4713 || Y>9999 || p->rawS ){

datetimeError(p);

return;

}

if( M<=2 ){

Y--;

M += 12;

}

A = (Y+4800)/100;

B = 38 - A + (A/4);

X1 = 36525*(Y+4716)/100;

X2 = 306001*(M+1)/10000;

p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);

p->validJD = 1;

if( p->validHMS ){

p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000 + 0.5);

if( p->tz ){

p->iJD -= p->tz*60000;

p->validYMD = 0;

p->validHMS = 0;

p->tz = 0;

p->isUtc = 1;

p->isLocal = 0;

}

** Given the YYYY-MM-DD information current in p, determine if there

** is day-of-month overflow and set nFloor to the number of days that

** would need to be subtracted from the date in order to bring the

** date back to the end of the month.

static void computeFloor(DateTime *p){

assert( p->validYMD || p->isError );

assert( p->D>=0 && p->D<=31 );

assert( p->M>=0 && p->M<=12 );

if( p->D<=28 ){

p->nFloor = 0;

}else if( (1<<p->M) & 0x15aa ){

p->nFloor = 0;

}else if( p->M!=2 ){

p->nFloor = (p->D==31);

}else if( p->Y%4!=0 || (p->Y%100==0 && p->Y%400!=0) ){

p->nFloor = p->D - 28;

}else{

p->nFloor = p->D - 29;

}

** Parse dates of the form

** YYYY-MM-DD HH:MM:SS.FFF

** YYYY-MM-DD HH:MM:SS

** YYYY-MM-DD HH:MM

** YYYY-MM-DD

** Write the result into the DateTime structure and return 0

** on success and 1 if the input string is not a well-formed

** date.

static int parseYyyyMmDd(const char *zDate, DateTime *p){

int Y, M, D, neg;

if( zDate[0]=='-' ){

zDate++;

neg = 1;

}else{

neg = 0;

}

if( getDigits(zDate, "40f-21a-21d", &Y, &M, &D)!=3 ){

return 1;

}

zDate += 10;

while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; }

if( parseHhMmSs(zDate, p)==0 ){

/* We got the time */

}else if( *zDate==0 ){

p->validHMS = 0;

}else{

return 1;

}

p->validJD = 0;

p->validYMD = 1;

p->Y = neg ? -Y : Y;

p->M = M;

p->D = D;

computeFloor(p);

if( p->tz ){

computeJD(p);

}

return 0;

}

static void clearYMD_HMS_TZ(DateTime *p); /* Forward declaration */

** Set the time to the current time reported by the VFS.

** Return the number of errors.

static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){

p->iJD = sqlite3StmtCurrentTime(context);

if( p->iJD>0 ){

p->validJD = 1;

p->isUtc = 1;

p->isLocal = 0;

clearYMD_HMS_TZ(p);

return 0;

}else{

return 1;

}

** Input "r" is a numeric quantity which might be a julian day number,

** or the number of seconds since 1970. If the value if r is within

** range of a julian day number, install it as such and set validJD.

** If the value is a valid unix timestamp, put it in p->s and set p->rawS.

static void setRawDateNumber(DateTime *p, double r){

p->s = r;

p->rawS = 1;

if( r>=0.0 && r<5373484.5 ){

p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);

p->validJD = 1;

}

** Attempt to parse the given string into a julian day number. Return

** the number of errors.

** The following are acceptable forms for the input string:

** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM

** DDDD.DD

** now

** In the first form, the +/-HH:MM is always optional. The fractional

** seconds extension (the ".FFF") is optional. The seconds portion

** (":SS.FFF") is option. The year and date can be omitted as long

** as there is a time string. The time string can be omitted as long

** as there is a year and date.

static int parseDateOrTime(

sqlite3_context *context,

const char *zDate,

DateTime *p

){

double r;

if( parseYyyyMmDd(zDate,p)==0 ){

return 0;

}else if( parseHhMmSs(zDate, p)==0 ){

return 0;

}else if( sqlite3StrICmp(zDate,"now")==0 && sqlite3NotPureFunc(context) ){

return setDateTimeToCurrent(context, p);

}else if( sqlite3AtoF(zDate, &r)>0 ){

setRawDateNumber(p, r);

return 0;

}else if( (sqlite3StrICmp(zDate,"subsec")==0

|| sqlite3StrICmp(zDate,"subsecond")==0)

&& sqlite3NotPureFunc(context) ){

p->useSubsec = 1;

return setDateTimeToCurrent(context, p);

}

return 1;

}

/* The julian day number for 9999-12-31 23:59:59.999 is 5373484.4999999.

** Multiplying this by 86400000 gives 464269060799999 as the maximum value

** for DateTime.iJD.

** But some older compilers (ex: gcc 4.2.1 on older Macs) cannot deal with

** such a large integer literal, so we have to encode it.

#define INT_464269060799999 ((((i64)0x1a640)<<32)|0x1072fdff)

** Return TRUE if the given julian day number is within range.

** The input is the JulianDay times 86400000.

static int validJulianDay(sqlite3_int64 iJD){

return iJD>=0 && iJD<=INT_464269060799999;

}

** Compute the Year, Month, and Day from the julian day number.

static void computeYMD(DateTime *p){

int Z, alpha, A, B, C, D, E, X1;

if( p->validYMD ) return;

if( !p->validJD ){

p->Y = 2000;

p->M = 1;

p->D = 1;

}else if( !validJulianDay(p->iJD) ){

datetimeError(p);

return;

}else{

Z = (int)((p->iJD + 43200000)/86400000);

alpha = (int)((Z + 32044.75)/36524.25) - 52;

A = Z + 1 + alpha - ((alpha+100)/4) + 25;

B = A + 1524;

C = (int)((B - 122.1)/365.25);

D = (36525*(C&32767))/100;

E = (int)((B-D)/30.6001);

X1 = (int)(30.6001*E);

p->D = B - D - X1;

p->M = E<14 ? E-1 : E-13;

p->Y = p->M>2 ? C - 4716 : C - 4715;

}

p->validYMD = 1;

}

** Compute the Hour, Minute, and Seconds from the julian day number.

static void computeHMS(DateTime *p){

int day_ms, day_min; /* milliseconds, minutes into the day */

if( p->validHMS ) return;

computeJD(p);

day_ms = (int)((p->iJD + 43200000) % 86400000);

p->s = (day_ms % 60000)/1000.0;

day_min = day_ms/60000;

p->m = day_min % 60;

p->h = day_min / 60;

p->rawS = 0;

p->validHMS = 1;

}

** Compute both YMD and HMS

static void computeYMD_HMS(DateTime *p){

computeYMD(p);

computeHMS(p);

}

** Clear the YMD and HMS and the TZ

static void clearYMD_HMS_TZ(DateTime *p){

p->validYMD = 0;

p->validHMS = 0;

p->tz = 0;

}

#ifndef SQLITE_OMIT_LOCALTIME

** On recent Windows platforms, the localtime_s() function is available

** as part of the "Secure CRT". It is essentially equivalent to

** localtime_r() available under most POSIX platforms, except that the

** order of the parameters is reversed.

** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx.

** If the user has not indicated to use localtime_r() or localtime_s()

** already, check for an MSVC build environment that provides

** localtime_s().

#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S \

&& defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE)

#undef HAVE_LOCALTIME_S

#define HAVE_LOCALTIME_S 1

#endif

** The following routine implements the rough equivalent of localtime_r()

** using whatever operating-system specific localtime facility that

** is available. This routine returns 0 on success and

** non-zero on any kind of error.

** If the sqlite3GlobalConfig.bLocaltimeFault variable is non-zero then this

** routine will always fail. If bLocaltimeFault is nonzero and

** sqlite3GlobalConfig.xAltLocaltime is not NULL, then xAltLocaltime() is

** invoked in place of the OS-defined localtime() function.

** EVIDENCE-OF: R-62172-00036 In this implementation, the standard C

** library function localtime_r() is used to assist in the calculation of

** local time.

static int osLocaltime(time_t *t, struct tm *pTm){

int rc;

#if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S

struct tm *pX;

#if SQLITE_THREADSAFE>0

sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);

#endif

sqlite3_mutex_enter(mutex);

pX = localtime(t);

#ifndef SQLITE_UNTESTABLE

if( sqlite3GlobalConfig.bLocaltimeFault ){

if( sqlite3GlobalConfig.xAltLocaltime!=0

&& 0==sqlite3GlobalConfig.xAltLocaltime((const void*)t,(void*)pTm)

){

pX = pTm;

}else{

pX = 0;

}

#endif

if( pX ) *pTm = *pX;

#if SQLITE_THREADSAFE>0

sqlite3_mutex_leave(mutex);

#endif

rc = pX==0;

#else

#ifndef SQLITE_UNTESTABLE

if( sqlite3GlobalConfig.bLocaltimeFault ){

if( sqlite3GlobalConfig.xAltLocaltime!=0 ){

return sqlite3GlobalConfig.xAltLocaltime((const void*)t,(void*)pTm);

}else{

return 1;

}

#endif

#if HAVE_LOCALTIME_R

rc = localtime_r(t, pTm)==0;

#else

rc = localtime_s(pTm, t);

#endif /* HAVE_LOCALTIME_R */

#endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */

return rc;

}

#endif /* SQLITE_OMIT_LOCALTIME */

#ifndef SQLITE_OMIT_LOCALTIME

** Assuming the input DateTime is UTC, move it to its localtime equivalent.

static int toLocaltime(

DateTime *p, /* Date at which to calculate offset */

sqlite3_context *pCtx /* Write error here if one occurs */

){

time_t t;

struct tm sLocal;

int iYearDiff;

/* Initialize the contents of sLocal to avoid a compiler warning. */

memset(&sLocal, 0, sizeof(sLocal));

computeJD(p);

if( p->iJD<2108667600*(i64)100000 /* 1970-01-01 */

|| p->iJD>2130141456*(i64)100000 /* 2038-01-18 */

){

/* EVIDENCE-OF: R-55269-29598 The localtime_r() C function normally only

** works for years between 1970 and 2037. For dates outside this range,

** SQLite attempts to map the year into an equivalent year within this

** range, do the calculation, then map the year back.

DateTime x = *p;

computeYMD_HMS(&x);

iYearDiff = (2000 + x.Y%4) - x.Y;

x.Y += iYearDiff;

x.validJD = 0;

computeJD(&x);

t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);

}else{

iYearDiff = 0;

t = (time_t)(p->iJD/1000 - 21086676*(i64)10000);

}

if( osLocaltime(&t, &sLocal) ){

sqlite3_result_error(pCtx, "local time unavailable", -1);

return SQLITE_ERROR;

}

p->Y = sLocal.tm_year + 1900 - iYearDiff;

p->M = sLocal.tm_mon + 1;

p->D = sLocal.tm_mday;

p->h = sLocal.tm_hour;

p->m = sLocal.tm_min;

p->s = sLocal.tm_sec + (p->iJD%1000)*0.001;

p->validYMD = 1;

p->validHMS = 1;

p->validJD = 0;

p->rawS = 0;

p->tz = 0;

p->isError = 0;

return SQLITE_OK;

}

#endif /* SQLITE_OMIT_LOCALTIME */

** The following table defines various date transformations of the form

** 'NNN days'

** Where NNN is an arbitrary floating-point number and "days" can be one

** of several units of time.

static const struct {

u8 nName; /* Length of the name */

char zName[7]; /* Name of the transformation */

float rLimit; /* Maximum NNN value for this transform */

float rXform; /* Constant used for this transform */

} aXformType[] = {

/* 0 */ { 6, "second", 4.6427e+14, 1.0 },

/* 1 */ { 6, "minute", 7.7379e+12, 60.0 },

/* 2 */ { 4, "hour", 1.2897e+11, 3600.0 },

/* 3 */ { 3, "day", 5373485.0, 86400.0 },

/* 4 */ { 5, "month", 176546.0, 2592000.0 },

/* 5 */ { 4, "year", 14713.0, 31536000.0 },

};

** If the DateTime p is raw number, try to figure out if it is

** a julian day number of a unix timestamp. Set the p value

** appropriately.

static void autoAdjustDate(DateTime *p){

if( !p->rawS || p->validJD ){

p->rawS = 0;

}else if( p->s>=-21086676*(i64)10000 /* -4713-11-24 12:00:00 */

&& p->s<=(25340230*(i64)10000)+799 /* 9999-12-31 23:59:59 */

){

double r = p->s*1000.0 + 210866760000000.0;

clearYMD_HMS_TZ(p);

p->iJD = (sqlite3_int64)(r + 0.5);

p->validJD = 1;

p->rawS = 0;

}

** Process a modifier to a date-time stamp. The modifiers are

** as follows:

** NNN days

** NNN hours

** NNN minutes

** NNN.NNNN seconds

** NNN months

** NNN years

** +/-YYYY-MM-DD HH:MM:SS.SSS

** ceiling

** floor

** start of month

** start of year

** start of week

** start of day

** weekday N

** unixepoch

** auto

** localtime

** utc

** subsec

** subsecond

** Return 0 on success and 1 if there is any kind of error. If the error

** is in a system call (i.e. localtime()), then an error message is written

** to context pCtx. If the error is an unrecognized modifier, no error is

** written to pCtx.

static int parseModifier(

sqlite3_context *pCtx, /* Function context */

const char *z, /* The text of the modifier */

int n, /* Length of zMod in bytes */

DateTime *p, /* The date/time value to be modified */

int idx /* Parameter index of the modifier */

){

int rc = 1;

double r;

switch(sqlite3UpperToLower[(u8)z[0]] ){

case 'a': {

** auto

** If rawS is available, then interpret as a julian day number, or

** a unix timestamp, depending on its magnitude.

if( sqlite3_stricmp(z, "auto")==0 ){

if( idx>1 ) return 1; /* IMP: R-33611-57934 */

autoAdjustDate(p);

rc = 0;

}

break;

}

case 'c': {

** ceiling

** Resolve day-of-month overflow by rolling forward into the next

** month. As this is the default action, this modifier is really

** a no-op that is only included for symmetry. See "floor".

if( sqlite3_stricmp(z, "ceiling")==0 ){

computeJD(p);

clearYMD_HMS_TZ(p);

rc = 0;

p->nFloor = 0;

}

break;

}

case 'f': {

** floor

** Resolve day-of-month overflow by rolling back to the end of the

** previous month.

if( sqlite3_stricmp(z, "floor")==0 ){

computeJD(p);

p->iJD -= p->nFloor*86400000;

clearYMD_HMS_TZ(p);

rc = 0;

}

break;

}

case 'j': {

** julianday

** Always interpret the prior number as a julian-day value. If this

** is not the first modifier, or if the prior argument is not a numeric

** value in the allowed range of julian day numbers understood by

** SQLite (0..5373484.5) then the result will be NULL.

if( sqlite3_stricmp(z, "julianday")==0 ){

if( idx>1 ) return 1; /* IMP: R-31176-64601 */

if( p->validJD && p->rawS ){

rc = 0;

p->rawS = 0;

}

break;

}

#ifndef SQLITE_OMIT_LOCALTIME

case 'l': {

/* localtime

** Assuming the current time value is UTC (a.k.a. GMT), shift it to

** show local time.

if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){

rc = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx);

p->isUtc = 0;

p->isLocal = 1;

}

break;

}

#endif

case 'u': {

** unixepoch

** Treat the current value of p->s as the number of

** seconds since 1970. Convert to a real julian day number.

if( sqlite3_stricmp(z, "unixepoch")==0 && p->rawS ){

if( idx>1 ) return 1; /* IMP: R-49255-55373 */

r = p->s*1000.0 + 210866760000000.0;

if( r>=0.0 && r<464269060800000.0 ){

clearYMD_HMS_TZ(p);

p->iJD = (sqlite3_int64)(r + 0.5);

p->validJD = 1;

p->rawS = 0;

rc = 0;

}

#ifndef SQLITE_OMIT_LOCALTIME

else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){

if( p->isUtc==0 ){

i64 iOrigJD; /* Original localtime */

i64 iGuess; /* Guess at the corresponding utc time */

int cnt = 0; /* Safety to prevent infinite loop */

i64 iErr; /* Guess is off by this much */

computeJD(p);

iGuess = iOrigJD = p->iJD;

iErr = 0;

do{

DateTime new;

memset(&new, 0, sizeof(new));

iGuess -= iErr;

new.iJD = iGuess;

new.validJD = 1;

rc = toLocaltime(&new, pCtx);

if( rc ) return rc;

computeJD(&new);

iErr = new.iJD - iOrigJD;

}while( iErr && cnt++<3 );

memset(p, 0, sizeof(*p));

p->iJD = iGuess;

p->validJD = 1;

p->isUtc = 1;

p->isLocal = 0;

}

rc = SQLITE_OK;

}

#endif

break;

}

case 'w': {

** weekday N

** Move the date to the same time on the next occurrence of

** weekday N where 0==Sunday, 1==Monday, and so forth. If the

** date is already on the appropriate weekday, this is a no-op.

if( sqlite3_strnicmp(z, "weekday ", 8)==0

&& sqlite3AtoF(&z[8], &r)>0

&& r>=0.0 && r<7.0 && (n=(int)r)==r ){

sqlite3_int64 Z;

computeYMD_HMS(p);

p->tz = 0;

p->validJD = 0;

computeJD(p);

Z = ((p->iJD + 129600000)/86400000) % 7;

if( Z>n ) Z -= 7;

p->iJD += (n - Z)*86400000;

clearYMD_HMS_TZ(p);

rc = 0;

}

break;

}

case 's': {

** start of TTTTT

** Move the date backwards to the beginning of the current day,

** or month or year.

** subsecond

** subsec

** Show subsecond precision in the output of datetime() and

** unixepoch() and strftime('%s').

if( sqlite3_strnicmp(z, "start of ", 9)!=0 ){

if( sqlite3_stricmp(z, "subsec")==0

|| sqlite3_stricmp(z, "subsecond")==0

){

p->useSubsec = 1;

rc = 0;

}

break;

}

if( !p->validJD && !p->validYMD && !p->validHMS ) break;

z += 9;

computeYMD(p);

p->validHMS = 1;

p->h = p->m = 0;

p->s = 0.0;

p->rawS = 0;

p->tz = 0;

p->validJD = 0;

if( sqlite3_stricmp(z,"month")==0 ){

p->D = 1;

rc = 0;

}else if( sqlite3_stricmp(z,"year")==0 ){

p->M = 1;

p->D = 1;

rc = 0;

}else if( sqlite3_stricmp(z,"day")==0 ){

rc = 0;

}

break;

}

case '+':

case '-':

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9': {

double rRounder;

int i, rx;

int Y,M,D,h,m,x;

const char *z2 = z;

char *zCopy;

sqlite3 *db = sqlite3_context_db_handle(pCtx);

char z0 = z[0];

for(n=1; z[n]; n++){

if( z[n]==':' ) break;

if( sqlite3Isspace(z[n]) ) break;

if( z[n]=='-' ){

if( n==5 && getDigits(&z[1], "40f", &Y)==1 ) break;

if( n==6 && getDigits(&z[1], "50f", &Y)==1 ) break;

}

zCopy = sqlite3DbStrNDup(db, z, n);

if( zCopy==0 ) break;

rx = sqlite3AtoF(zCopy, &r)<=0;

sqlite3DbFree(db, zCopy);

if( rx ){

assert( rc==1 );

break;

}

if( z[n]=='-' ){

/* A modifier of the form (+|-)YYYY-MM-DD adds or subtracts the

** specified number of years, months, and days. MM is limited to

** the range 0-11 and DD is limited to 0-30.

if( z0!='+' && z0!='-' ) break; /* Must start with +/- */

if( n==5 ){

if( getDigits(&z[1], "40f-20a-20d", &Y, &M, &D)!=3 ) break;

}else{

assert( n==6 );

if( getDigits(&z[1], "50f-20a-20d", &Y, &M, &D)!=3 ) break;

z++;

}

if( M>=12 ) break; /* M range 0..11 */

if( D>=31 ) break; /* D range 0..30 */

computeYMD_HMS(p);

p->validJD = 0;

if( z0=='-' ){

p->Y -= Y;

p->M -= M;

D = -D;

}else{

p->Y += Y;

p->M += M;

}

x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;

p->Y += x;

p->M -= x*12;

computeFloor(p);

computeJD(p);

View remainder of file in raw view

sqlcipher/src/date.c at sqlite-release · sqlcipher/sqlcipher · GitHub

Uh oh!

Expand file tree

Breadcrumbs

date.c

Latest commit

History

Breadcrumbs

date.c

File metadata and controls