From b7733bccee0c08627ef44c7825d41da7827cbdd7 Mon Sep 17 00:00:00 2001 From: leiju <3074194431@qq.com> Date: Sun, 2 Sep 2018 19:37:18 +0800 Subject: [PATCH] add smart_home_server --- smart_home_server/Makefile | 11 + smart_home_server/camera.c | 236 + smart_home_server/camera_process.c | 156 + smart_home_server/convert.c | 232 + smart_home_server/include/camera.h | 11 + smart_home_server/include/camera_process.h | 12 + smart_home_server/include/convert.h | 9 + smart_home_server/include/jpg.h | 11 + smart_home_server/include/modul.h | 25 + smart_home_server/include/serial.h | 40 + smart_home_server/include/server.h | 33 + smart_home_server/include/shm.h | 19 + smart_home_server/include/sqlite3.h | 7174 + smart_home_server/include/tcp.h | 21 + smart_home_server/main | Bin 0 -> 799180 bytes smart_home_server/main.c | 34 + smart_home_server/modul.c | 176 + smart_home_server/serial.c | 251 + smart_home_server/server.c | 312 + smart_home_server/shm.c | 51 + smart_home_server/sqlite.c | 277 + smart_home_server/sqlite3.c | 138114 ++++++++++++++++++ smart_home_server/srv.c | 54 + smart_home_server/tcp.c | 301 + 24 files changed, 147560 insertions(+) create mode 100755 smart_home_server/Makefile create mode 100755 smart_home_server/camera.c create mode 100755 smart_home_server/camera_process.c create mode 100755 smart_home_server/convert.c create mode 100755 smart_home_server/include/camera.h create mode 100755 smart_home_server/include/camera_process.h create mode 100755 smart_home_server/include/convert.h create mode 100755 smart_home_server/include/jpg.h create mode 100755 smart_home_server/include/modul.h create mode 100755 smart_home_server/include/serial.h create mode 100755 smart_home_server/include/server.h create mode 100755 smart_home_server/include/shm.h create mode 100755 smart_home_server/include/sqlite3.h create mode 100755 smart_home_server/include/tcp.h create mode 100755 smart_home_server/main create mode 100755 smart_home_server/main.c create mode 100755 smart_home_server/modul.c create mode 100755 smart_home_server/serial.c create mode 100755 smart_home_server/server.c create mode 100755 smart_home_server/shm.c create mode 100755 smart_home_server/sqlite.c create mode 100755 smart_home_server/sqlite3.c create mode 100755 smart_home_server/srv.c create mode 100755 smart_home_server/tcp.c diff --git a/smart_home_server/Makefile b/smart_home_server/Makefile new file mode 100755 index 0000000..2fb35ca --- /dev/null +++ b/smart_home_server/Makefile @@ -0,0 +1,11 @@ + +OBJS=main.c server.c camera.c convert.c srv.c tcp.c sqlite.c camera_process.c sqlite3.c modul.c shm.c serial.c +CC=arm-none-linux-gnueabi-gcc +TARGET=main + +$(TARGET):$(OBJS) + $(CC) $^ -o $@ -lpthread -ldl -ljpeg -L/home/linux/jpeg_9/lib + +clean: + rm -rf $(TARGET) + rm *~ diff --git a/smart_home_server/camera.c b/smart_home_server/camera.c new file mode 100755 index 0000000..0f905da --- /dev/null +++ b/smart_home_server/camera.c @@ -0,0 +1,236 @@ +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +#define REQBUFS_COUNT 4 + +struct cam_buf { + void *start; + size_t length; +}; + +struct v4l2_requestbuffers reqbufs; +struct cam_buf bufs[REQBUFS_COUNT]; + +int camera_init(char *devpath, unsigned int *width, unsigned int *height, unsigned int *size, unsigned int *ismjpeg) +{ + int i; + int fd; + int ret; + struct v4l2_buffer vbuf; + struct v4l2_format format; + struct v4l2_capability capability; + + fd = open(devpath, O_RDWR); + if (fd == -1) { + perror("camera->init"); + return -1; + } + + ret = ioctl(fd, VIDIOC_QUERYCAP, &capability); + if (ret == -1) { + perror("camera->init"); + return -1; + } + + if(!(capability.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { + fprintf(stderr, "camera->init: device can not support V4L2_CAP_VIDEO_CAPTURE\n"); + close(fd); + return -1; + } + + if(!(capability.capabilities & V4L2_CAP_STREAMING)) { + fprintf(stderr, "camera->init: device can not support V4L2_CAP_STREAMING\n"); + close(fd); + return -1; + } + + memset(&format, 0, sizeof(format)); + format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; + format.fmt.pix.width = *width; + format.fmt.pix.height = *height; + format.fmt.pix.field = V4L2_FIELD_ANY; + ret = ioctl(fd, VIDIOC_S_FMT, &format); + if(ret == -1) { + perror("camera init"); + return -1; + } else { + *ismjpeg = 0; + fprintf(stdout, "camera->init: picture format is yuyv\n"); + } + +//get_fmt: + ret = ioctl(fd, VIDIOC_G_FMT, &format); + if (ret == -1) { + perror("camera init"); + return -1; + } + + memset(&reqbufs, 0, sizeof(struct v4l2_requestbuffers)); + reqbufs.count = REQBUFS_COUNT; + reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + reqbufs.memory = V4L2_MEMORY_MMAP; + ret = ioctl(fd, VIDIOC_REQBUFS, &reqbufs); + if (ret == -1) { + perror("camera init"); + close(fd); + return -1; + } + + for (i = 0; i < reqbufs.count; i++) + { + memset(&vbuf, 0, sizeof(struct v4l2_buffer)); + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + vbuf.index = i; + ret = ioctl(fd, VIDIOC_QUERYBUF, &vbuf); + if (ret == -1) { + perror("camera init"); + close(fd); + return -1; + } + + bufs[i].length = vbuf.length; + bufs[i].start = mmap(NULL, vbuf.length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, vbuf.m.offset); + if (bufs[i].start == MAP_FAILED) + { + perror("camera init"); + close(fd); + return -1; + } + + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + ret = ioctl(fd, VIDIOC_QBUF, &vbuf); + if (ret == -1) { + perror("camera init"); + close(fd); + return -1; + } + } + + *width = format.fmt.pix.width; + *height = format.fmt.pix.height; + *size = bufs[0].length; + + return fd; +} + +int camera_start(int fd) +{ + int ret; + enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + + ret = ioctl(fd, VIDIOC_STREAMON, &type); + if (ret == -1) { + perror("camera->start"); + return -1; + } + fprintf(stdout, "camera->start: start capture\n"); + + return 0; +} + +int camera_dqbuf(int fd, void **buf, unsigned int *size, unsigned int *index) +{ + int ret; + fd_set fds; + struct timeval timeout; + struct v4l2_buffer vbuf; + + while (1) { + FD_ZERO(&fds); + FD_SET(fd, &fds); + timeout.tv_sec = 2; + timeout.tv_usec = 0; + ret = select(fd + 1, &fds, NULL, NULL, &timeout); + if (ret == -1) { + perror("camera->dqbuf"); + if (errno == EINTR) + continue; + else + return -1; + } else if (ret == 0) { + fprintf(stderr, "camera->dqbuf: dequeue buffer timeout\n"); + continue; + } else { + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + ret = ioctl(fd, VIDIOC_DQBUF, &vbuf); + if (ret == -1) { + perror("camera->dqbuf"); + return -1; + } + *buf = bufs[vbuf.index].start; + *size = vbuf.bytesused; + *index = vbuf.index; + + return 0; + } + } +} + +int camera_eqbuf(int fd, unsigned int index) +{ + int ret; + struct v4l2_buffer vbuf; + + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + vbuf.index = index; + ret = ioctl(fd, VIDIOC_QBUF, &vbuf); + if (ret == -1) { + perror("camera->eqbuf"); + return -1; + } + + return 0; +} + +int camera_stop(int fd) +{ + int ret; + enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + + ret = ioctl(fd, VIDIOC_STREAMOFF, &type); + if (ret == -1) { + perror("camera->stop"); + return -1; + } + fprintf(stdout, "camera->stop: stop capture\n"); + + return 0; +} + +int camera_exit(int fd) +{ + int i; + int ret; + struct v4l2_buffer vbuf; + + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + + for (i = 0; i < reqbufs.count; i++) { + ret = ioctl(fd, VIDIOC_DQBUF, &vbuf); + if (ret == -1) + break; + } + + for (i = 0; i < reqbufs.count; i++) + munmap(bufs[i].start, bufs[i].length); + + fprintf(stdout, "camera->exit: camera exit\n"); + + return close(fd); +} + diff --git a/smart_home_server/camera_process.c b/smart_home_server/camera_process.c new file mode 100755 index 0000000..71e176c --- /dev/null +++ b/smart_home_server/camera_process.c @@ -0,0 +1,156 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "./include/tcp.h" +#include "./include/camera.h" +#include "./include/jpg.h" +#include "./include/convert.h" +#include "./include/camera_process.h" + +#define CAMERA_DEV_PATH "/dev/video0" + +struct jpg_buf_t *jpg; +pthread_t cam_tid; +pthread_mutex_t jpg_mutex; + +void *thread_cam(void *arg); +void *thread_srv(void *arg); +extern int client_process(int connfd, struct jpg_buf_t *jpg); + +void camera_process() +{ + int ret; + + pthread_mutex_init(&jpg_mutex, NULL); + + ret = pthread_create(&cam_tid, NULL, thread_cam, NULL); + if (ret) { + errno = ret; + perror("create camera thread"); + exit(EXIT_FAILURE); + } else + printf("create camera thread success\n"); + + ret = pthread_detach(cam_tid); + if (ret) { + errno = ret; + perror("detach camera thread"); + exit(EXIT_FAILURE); + } else + printf("detach camera thread success\n"); + + thread_srv(NULL); + + exit(EXIT_SUCCESS); +} + +void *thread_cam(void *arg) +{ + int i; + int fd; + int ret; + unsigned int width; + unsigned int height; + unsigned int size; + unsigned int index; + unsigned int ismjpeg; + char *yuv; + char *rgb; + + /* A8的屏幕比较小，所以设了较低的像素 */ + width = 1024; + height = 768; + fd = camera_init(CAMERA_DEV_PATH, &width, &height, &size, &ismjpeg); + if (fd == -1) + exit(EXIT_FAILURE); + printf("width: %d\n", width); + printf("height: %d\n", height); + + ret = camera_start(fd); + if (ret == -1) + exit(EXIT_FAILURE); + + jpg = malloc(sizeof(struct jpg_buf_t)); + if (!jpg) { + perror("malloc"); + exit(EXIT_FAILURE); + } + + if (!ismjpeg) { + rgb = malloc(width * height * 3); + convert_rgb_to_jpg_init(); + } + + /* 采集几张图片丢弃 */ + for (i = 0; i < 8; i++) { + ret = camera_dqbuf(fd, (void **)&yuv, &size, &index); + if (ret == -1) + exit(EXIT_FAILURE); + + ret = camera_eqbuf(fd, index); + if (ret == -1) + exit(EXIT_FAILURE); + } + + fprintf(stdout, "init camera success\n"); + + + /* 循环采集图片 */ + while (1) { + ret = camera_dqbuf(fd, (void **)&yuv, &size, &index); + if (ret == -1) + exit(EXIT_FAILURE); + + convert_yuv_to_rgb(yuv, rgb, width, height, 24); + pthread_mutex_lock(&jpg_mutex); + jpg->len = convert_rgb_to_jpg_work(rgb, jpg->buf, width, height, 24, 80); + pthread_mutex_unlock(&jpg_mutex); + + ret = camera_eqbuf(fd, index); + if (ret == -1) + exit(EXIT_FAILURE); + } + + /* 代码不应该运行到这里 */ + if (!ismjpeg) { + convert_rgb_to_jpg_exit(); + free(rgb); + } + free(jpg); + + ret = camera_stop(fd); + if (ret == -1) + exit(EXIT_FAILURE); + + ret = camera_exit(fd); + if (ret == -1) + exit(EXIT_FAILURE); +} + +void *thread_srv(void *arg) +{ + int listenfd; + int connfd; + + listenfd = tcp_server_init(NULL, "8888"); + if (listenfd == -1) + exit(EXIT_FAILURE); + else + fprintf(stdout, "init server success\n"); + + while (1) { + if ((connfd = tcp_server_wait_connect(listenfd)) != -1) { + while (1) { + if (client_process(connfd, jpg) == -1) { + tcp_server_disconnect(connfd); + break; + } + } + } + } +} diff --git a/smart_home_server/convert.c b/smart_home_server/convert.c new file mode 100755 index 0000000..d4eca0d --- /dev/null +++ b/smart_home_server/convert.c @@ -0,0 +1,232 @@ +#include +#include +#include +#include +#include +#include +#include + +#define ROUND_0_255(v) ((v) < 0 ? 0 : ((v) > 255 ? 255 : (v))) + +typedef struct { + struct jpeg_destination_mgr pub; + JOCTET *buffer; + unsigned char *outbuffer; + int outbuffer_size; + unsigned char *outbuffer_cursor; + int *written; +} jpeg_dest_mgr, *jpeg_dest_mgr_ptr; + +struct jpeg_mgr_info { + unsigned long written; + JSAMPROW row_pointer[1]; + struct jpeg_error_mgr jerr; + struct jpeg_compress_struct cinfo; +}; + +static struct jpeg_mgr_info jinfo; + +static short radj[] = { + -175, -174, -172, -171, -169, -168, -167, -165, + -164, -163, -161, -160, -159, -157, -156, -154, + -153, -152, -150, -149, -148, -146, -145, -143, + -142, -141, -139, -138, -137, -135, -134, -132, + -131, -130, -128, -127, -126, -124, -123, -121, + -120, -119, -117, -116, -115, -113, -112, -111, + -109, -108, -106, -105, -104, -102, -101, -100, + -98, -97, -95, -94, -93, -91, -90, -89, + -87, -86, -84, -83, -82, -80, -79, -78, + -76, -75, -74, -72, -71, -69, -68, -67, + -65, -64, -63, -61, -60, -58, -57, -56, + -54, -53, -52, -50, -49, -47, -46, -45, + -43, -42, -41, -39, -38, -37, -35, -34, + -32, -31, -30, -28, -27, -26, -24, -23, + -21, -20, -19, -17, -16, -15, -13, -12, + -10, -9, -8, -6, -5, -4, -2, -1, + 0, 1, 2, 4, 5, 6, 8, 9, + 10, 12, 13, 15, 16, 17, 19, 20, + 21, 23, 24, 26, 27, 28, 30, 31, + 32, 34, 35, 37, 38, 39, 41, 42, + 43, 45, 46, 47, 49, 50, 52, 53, + 54, 56, 57, 58, 60, 61, 63, 64, + 65, 67, 68, 69, 71, 72, 74, 75, + 76, 78, 79, 80, 82, 83, 84, 86, + 87, 89, 90, 91, 93, 94, 95, 97, + 98, 100, 101, 102, 104, 105, 106, 108, + 109, 111, 112, 113, 115, 116, 117, 119, + 120, 121, 123, 124, 126, 127, 128, 130, + 131, 132, 134, 135, 137, 138, 139, 141, + 142, 143, 145, 146, 148, 149, 150, 152, + 153, 154, 156, 157, 159, 160, 161, 163, + 164, 165, 167, 168, 169, 171, 172, 174, +}; + +static short gadj1[] = { + -89, -88, -87, -87, -86, -85, -85, -84, + -83, -83, -82, -81, -80, -80, -79, -78, + -78, -77, -76, -76, -75, -74, -73, -73, + -72, -71, -71, -70, -69, -69, -68, -67, + -67, -66, -65, -64, -64, -63, -62, -62, + -61, -60, -60, -59, -58, -57, -57, -56, + -55, -55, -54, -53, -53, -52, -51, -50, + -50, -49, -48, -48, -47, -46, -46, -45, + -44, -43, -43, -42, -41, -41, -40, -39, + -39, -38, -37, -36, -36, -35, -34, -34, + -33, -32, -32, -31, -30, -30, -29, -28, + -27, -27, -26, -25, -25, -24, -23, -23, + -22, -21, -20, -20, -19, -18, -18, -17, + -16, -16, -15, -14, -13, -13, -12, -11, + -11, -10, -9, -9, -8, -7, -6, -6, + -5, -4, -4, -3, -2, -2, -1, 0, + 0, 0, 1, 2, 2, 3, 4, 4, + 5, 6, 6, 7, 8, 9, 9, 10, + 11, 11, 12, 13, 13, 14, 15, 16, + 16, 17, 18, 18, 19, 20, 20, 21, + 22, 23, 23, 24, 25, 25, 26, 27, + 27, 28, 29, 30, 30, 31, 32, 32, + 33, 34, 34, 35, 36, 36, 37, 38, + 39, 39, 40, 41, 41, 42, 43, 43, + 44, 45, 46, 46, 47, 48, 48, 49, + 50, 50, 51, 52, 53, 53, 54, 55, + 55, 56, 57, 57, 58, 59, 60, 60, + 61, 62, 62, 63, 64, 64, 65, 66, + 67, 67, 68, 69, 69, 70, 71, 71, + 72, 73, 73, 74, 75, 76, 76, 77, + 78, 78, 79, 80, 80, 81, 82, 83, + 83, 84, 85, 85, 86, 87, 87, 88, +}; + +static short gadj2[] = { + -43, -42, -42, -42, -41, -41, -41, -40, + -40, -40, -39, -39, -39, -38, -38, -38, + -37, -37, -37, -36, -36, -36, -35, -35, + -35, -34, -34, -34, -33, -33, -33, -32, + -32, -32, -31, -31, -31, -30, -30, -30, + -29, -29, -29, -28, -28, -28, -27, -27, + -27, -26, -26, -25, -25, -25, -24, -24, + -24, -23, -23, -23, -22, -22, -22, -21, + -21, -21, -20, -20, -20, -19, -19, -19, + -18, -18, -18, -17, -17, -17, -16, -16, + -16, -15, -15, -15, -14, -14, -14, -13, + -13, -13, -12, -12, -12, -11, -11, -11, + -10, -10, -10, -9, -9, -9, -8, -8, + -8, -7, -7, -7, -6, -6, -6, -5, + -5, -5, -4, -4, -4, -3, -3, -3, + -2, -2, -2, -1, -1, -1, 0, 0, + 0, 0, 0, 1, 1, 1, 2, 2, + 2, 3, 3, 3, 4, 4, 4, 5, + 5, 5, 6, 6, 6, 7, 7, 7, + 8, 8, 8, 9, 9, 9, 10, 10, + 10, 11, 11, 11, 12, 12, 12, 13, + 13, 13, 14, 14, 14, 15, 15, 15, + 16, 16, 16, 17, 17, 17, 18, 18, + 18, 19, 19, 19, 20, 20, 20, 21, + 21, 21, 22, 22, 22, 23, 23, 23, + 24, 24, 24, 25, 25, 25, 26, 26, + 27, 27, 27, 28, 28, 28, 29, 29, + 29, 30, 30, 30, 31, 31, 31, 32, + 32, 32, 33, 33, 33, 34, 34, 34, + 35, 35, 35, 36, 36, 36, 37, 37, + 37, 38, 38, 38, 39, 39, 39, 40, + 40, 40, 41, 41, 41, 42, 42, 42, +}; + +static short badj[] = { + -221, -220, -218, -216, -214, -213, -211, -209, + -207, -206, -204, -202, -200, -199, -197, -195, + -194, -192, -190, -188, -187, -185, -183, -181, + -180, -178, -176, -174, -173, -171, -169, -168, + -166, -164, -162, -161, -159, -157, -155, -154, + -152, -150, -148, -147, -145, -143, -142, -140, + -138, -136, -135, -133, -131, -129, -128, -126, + -124, -123, -121, -119, -117, -116, -114, -112, + -110, -109, -107, -105, -103, -102, -100, -98, + -97, -95, -93, -91, -90, -88, -86, -84, + -83, -81, -79, -77, -76, -74, -72, -71, + -69, -67, -65, -64, -62, -60, -58, -57, + -55, -53, -51, -50, -48, -46, -45, -43, + -41, -39, -38, -36, -34, -32, -31, -29, + -27, -25, -24, -22, -20, -19, -17, -15, + -13, -12, -10, -8, -6, -5, -3, -1, + 0, 1, 3, 5, 6, 8, 10, 12, + 13, 15, 17, 19, 20, 22, 24, 25, + 27, 29, 31, 32, 34, 36, 38, 39, + 41, 43, 45, 46, 48, 50, 51, 53, + 55, 57, 58, 60, 62, 64, 65, 67, + 69, 71, 72, 74, 76, 77, 79, 81, + 83, 84, 86, 88, 90, 91, 93, 95, + 97, 98, 100, 102, 103, 105, 107, 109, + 110, 112, 114, 116, 117, 119, 121, 123, + 124, 126, 128, 129, 131, 133, 135, 136, + 138, 140, 142, 143, 145, 147, 148, 150, + 152, 154, 155, 157, 159, 161, 162, 164, + 166, 168, 169, 171, 173, 174, 176, 178, + 180, 181, 183, 185, 187, 188, 190, 192, + 194, 195, 197, 199, 200, 202, 204, 206, + 207, 209, 211, 213, 214, 216, 218, 220, +}; + +void convert_yuv_to_rgb(void *yuv, void *rgb, unsigned int width, unsigned int height, unsigned int bps) +{ + unsigned int i; + int y1, y2, u, v; + unsigned char *src = yuv; + unsigned char *dst = rgb; + unsigned int count = width * height / 2; + + switch (bps) { + case 24: + for (i = 0; i < count; i++) { + y1 = *src++; + u = *src++; + y2 = *src++; + v = *src++; + + *dst++ = ROUND_0_255(y1 + radj[v]); + *dst++ = ROUND_0_255(y1 - gadj1[u] - gadj2[v]); + *dst++ = ROUND_0_255(y1 + badj[u]); + + *dst++ = ROUND_0_255(y2 + radj[v]); + *dst++ = ROUND_0_255(y2 - gadj1[u] - gadj2[v]); + *dst++ = ROUND_0_255(y2 + badj[u]); + } + break; + } +} + +void convert_rgb_to_jpg_init(void) +{ + memset(&jinfo, 0, sizeof(struct jpeg_mgr_info)); + jinfo.cinfo.err = jpeg_std_error(&jinfo.jerr); + jpeg_create_compress(&jinfo.cinfo); +} + +int convert_rgb_to_jpg_work(void *rgb, void *jpeg, unsigned int width, unsigned int height, unsigned int bpp, int quality) +{ + jinfo.written = width * height * bpp / 3; + jpeg_mem_dest(&jinfo.cinfo, (unsigned char **)&jpeg, &jinfo.written); + + jinfo.cinfo.image_width = width; + jinfo.cinfo.image_height = height; + jinfo.cinfo.input_components = bpp / 8; + jinfo.cinfo.in_color_space = JCS_RGB; + jpeg_set_defaults(&jinfo.cinfo); + jpeg_set_quality(&jinfo.cinfo, quality, TRUE); + + jpeg_start_compress(&jinfo.cinfo, TRUE); + + while(jinfo.cinfo.next_scanline < height) { + jinfo.row_pointer[0] = rgb + jinfo.cinfo.next_scanline * width * bpp / 8; + jpeg_write_scanlines(&jinfo.cinfo, jinfo.row_pointer, 1); + } + + jpeg_finish_compress(&jinfo.cinfo); + + return (jinfo.written); +} + +void convert_rgb_to_jpg_exit(void) +{ + jpeg_destroy_compress(&jinfo.cinfo); +} + diff --git a/smart_home_server/include/camera.h b/smart_home_server/include/camera.h new file mode 100755 index 0000000..ad271bb --- /dev/null +++ b/smart_home_server/include/camera.h @@ -0,0 +1,11 @@ +#ifndef __CAM_H__ +#define __CAM_H__ + +int camera_init(char *devpath, unsigned int *width, unsigned int *height, unsigned int *size, unsigned int *ismjpeg); +int camera_start(int fd); +int camera_dqbuf(int fd, void **buf, unsigned int *size, unsigned int *index); +int camera_eqbuf(int fd, unsigned int index); +int camera_stop(int fd); +int camera_exit(int fd); + +#endif diff --git a/smart_home_server/include/camera_process.h b/smart_home_server/include/camera_process.h new file mode 100755 index 0000000..29ae638 --- /dev/null +++ b/smart_home_server/include/camera_process.h @@ -0,0 +1,12 @@ +/************************************************************************* + > File Name: camera_process.h + > Author: lei + > Mail: + > Created Time: Thu 30 Aug 2018 09:09:34 AM CST + ************************************************************************/ +#ifndef CAMERA_PROCESS_H +#define CAMERA_PROCESS_H +void camera_process(); + +#endif + diff --git a/smart_home_server/include/convert.h b/smart_home_server/include/convert.h new file mode 100755 index 0000000..5a4e3ac --- /dev/null +++ b/smart_home_server/include/convert.h @@ -0,0 +1,9 @@ +#ifndef __CONVERT_H__ +#define __CONVERT_H__ + +void convert_yuv_to_rgb(void *yuv, void *rgb, unsigned int width, unsigned int height, unsigned int bps); +void convert_rgb_to_jpg_init(void); +int convert_rgb_to_jpg_work(void *rgb, void *jpeg, unsigned int width, unsigned int height, unsigned int bpp, int quality); +void convert_rgb_to_jpg_exit(void); + +#endif diff --git a/smart_home_server/include/jpg.h b/smart_home_server/include/jpg.h new file mode 100755 index 0000000..a43f249 --- /dev/null +++ b/smart_home_server/include/jpg.h @@ -0,0 +1,11 @@ +#ifndef __JPG_H__ +#define __JPG_H__ + +#define MAX_JPG_SIZE (1024 * 1024 - sizeof (unsigned int)) + +struct jpg_buf_t { + unsigned char buf[MAX_JPG_SIZE]; + unsigned int len; +}; + +#endif diff --git a/smart_home_server/include/modul.h b/smart_home_server/include/modul.h new file mode 100755 index 0000000..ccda4f1 --- /dev/null +++ b/smart_home_server/include/modul.h @@ -0,0 +1,25 @@ +#ifndef __MODUL_H__ +#define __MODUL_H__ +struct env_char{ + char led_one; + char led_two; + char fan; + char h_tem; + char l_tem; + char h_hum; + char l_hum; + char first_light; + char second_light; + char third_light; + char forth_light; +}; +struct env_char env_char_data; +int zigbee_init( char *devpath, int baudrate); +int zigbee_get_dat(int fd); +int zigbee_exe_cmd(int fd, unsigned char *p); +int zigbee_exit(int fd); +void send_cmd_m0(int signo); + + + +#endif diff --git a/smart_home_server/include/serial.h b/smart_home_server/include/serial.h new file mode 100755 index 0000000..8de9064 --- /dev/null +++ b/smart_home_server/include/serial.h @@ -0,0 +1,40 @@ +#ifndef __SERIAL_H__ +#define __SERIAL_H__ + + +struct env{ + int id; + float tem; + float hum; + int light; + int x; + int y; + int z; + unsigned char led ; + unsigned char fan; + unsigned char buzz; +}; +struct env data; + +/** + * 打开串口设备 + * @param[in] devpath 串口设备路径 + * @return 打开的文件描述符 + * @retval 0 打开设备失败，原因见errno + */ +int serial_open(char *devpath) ; + +void serial_Close(int fd) ; +int serial_Set(int fd, int speed, int flow_ctrl, int databits, int stopbits, int parity) ; +int serial_init(char *devpath) ; +int serial_recv_exact_nbytes(int fd, void *buf, int count); +int serial_send_exact_nbytes(int fd, unsigned char *buf, int count); +int serial_exit(int fd); + + + + + + + +#endif diff --git a/smart_home_server/include/server.h b/smart_home_server/include/server.h new file mode 100755 index 0000000..1eacb71 --- /dev/null +++ b/smart_home_server/include/server.h @@ -0,0 +1,33 @@ +/************************************************************************* + > File Name: server.h + > Author: lei + > Mail: + > Created Time: Thu 30 Aug 2018 09:11:59 AM CST + ************************************************************************/ + +#ifndef A9_PROCESS +#define A9_PROCESS +#include "sqlite3.h" +#include +#include +#include + +int zgbfd; +#define FILEPATH_MAX (80) +#define Line_Max 12 +int A9_process(); + +char * getPath(char *dbName); +struct sqlite3 * SqlOpen(char* pPath); +int sqlCount(struct sqlite3 *pdb,char *tabname ); +void SqlInsert1(struct sqlite3 *pdb,char *tabname,float tempMax,float tempMin,float humMax,float humMin,float luxMax, float luxMin,float ppmMax,float ppmMin ); +void SqlInsert(struct sqlite3 *pdb,char *tabname,float temp,float hum,float lux ,float ppm ); +void SqlCreatTable(struct sqlite3 *pdb,char* tabname); +void SqlCreatTable1(struct sqlite3 *pdb,char* tabname); +int sqlSelected(char * tabname,struct sqlite3 *pdb); +void if_tabExit(char* tabname,struct sqlite3 *pdb); +void sqlDelete(char * tabname,struct sqlite3 *pdb,int templine); +int sqlGetData(char * tabname,struct sqlite3 *pdb); +void show(); + +#endif diff --git a/smart_home_server/include/shm.h b/smart_home_server/include/shm.h new file mode 100755 index 0000000..dc0979b --- /dev/null +++ b/smart_home_server/include/shm.h @@ -0,0 +1,19 @@ +#ifndef _SHM_ +#define _SHM_ + +#include +#include +#include +#include +#include + +#define SIZE 1024 +#define PATH "." +#define BUF_SIZE 32 + +char *create_shm(); +void read_shm(char *shm,void *env, int len); +void write_shm(char *shm,void *env, int len); +void delete_shm(char *p_shm); + +#endif diff --git a/smart_home_server/include/sqlite3.h b/smart_home_server/include/sqlite3.h new file mode 100755 index 0000000..1332eb1 --- /dev/null +++ b/smart_home_server/include/sqlite3.h @@ -0,0 +1,7174 @@ +/* +** 2001 September 15 +** +** 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 header file defines the interface that the SQLite library +** presents to client programs. If a C-function, structure, datatype, +** or constant definition does not appear in this file, then it is +** not a published API of SQLite, is subject to change without +** notice, and should not be referenced by programs that use SQLite. +** +** Some of the definitions that are in this file are marked as +** "experimental". Experimental interfaces are normally new +** features recently added to SQLite. We do not anticipate changes +** to experimental interfaces but reserve the right to make minor changes +** if experience from use "in the wild" suggest such changes are prudent. +** +** The official C-language API documentation for SQLite is derived +** from comments in this file. This file is the authoritative source +** on how SQLite interfaces are suppose to operate. +** +** The name of this file under configuration management is "sqlite.h.in". +** The makefile makes some minor changes to this file (such as inserting +** the version number) and changes its name to "sqlite3.h" as +** part of the build process. +*/ +#ifndef _SQLITE3_H_ +#define _SQLITE3_H_ +#include /* Needed for the definition of va_list */ + +/* +** Make sure we can call this stuff from C++. +*/ +#ifdef __cplusplus +extern "C" { +#endif + + +/* +** Add the ability to override 'extern' +*/ +#ifndef SQLITE_EXTERN +# define SQLITE_EXTERN extern +#endif + +#ifndef SQLITE_API +# define SQLITE_API +#endif + + +/* +** These no-op macros are used in front of interfaces to mark those +** interfaces as either deprecated or experimental. New applications +** should not use deprecated interfaces - they are support for backwards +** compatibility only. Application writers should be aware that +** experimental interfaces are subject to change in point releases. +** +** These macros used to resolve to various kinds of compiler magic that +** would generate warning messages when they were used. But that +** compiler magic ended up generating such a flurry of bug reports +** that we have taken it all out and gone back to using simple +** noop macros. +*/ +#define SQLITE_DEPRECATED +#define SQLITE_EXPERIMENTAL + +/* +** Ensure these symbols were not defined by some previous header file. +*/ +#ifdef SQLITE_VERSION +# undef SQLITE_VERSION +#endif +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif + +/* +** CAPI3REF: Compile-Time Library Version Numbers +** +** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header +** evaluates to a string literal that is the SQLite version in the +** format "X.Y.Z" where X is the major version number (always 3 for +** SQLite3) and Y is the minor version number and Z is the release number.)^ +** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer +** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same +** numbers used in [SQLITE_VERSION].)^ +** The SQLITE_VERSION_NUMBER for any given release of SQLite will also +** be larger than the release from which it is derived. Either Y will +** be held constant and Z will be incremented or else Y will be incremented +** and Z will be reset to zero. +** +** Since version 3.6.18, SQLite source code has been stored in the +** Fossil configuration management +** system. ^The SQLITE_SOURCE_ID macro evaluates to +** a string which identifies a particular check-in of SQLite +** within its configuration management system. ^The SQLITE_SOURCE_ID +** string contains the date and time of the check-in (UTC) and an SHA1 +** hash of the entire source tree. +** +** See also: [sqlite3_libversion()], +** [sqlite3_libversion_number()], [sqlite3_sourceid()], +** [sqlite_version()] and [sqlite_source_id()]. +*/ +#define SQLITE_VERSION "3.7.16.1" +#define SQLITE_VERSION_NUMBER 3007016 +#define SQLITE_SOURCE_ID "2013-03-29 13:44:34 527231bc67285f01fb18d4451b28f61da3c4e39d" + +/* +** CAPI3REF: Run-Time Library Version Numbers +** KEYWORDS: sqlite3_version, sqlite3_sourceid +** +** These interfaces provide the same information as the [SQLITE_VERSION], +** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros +** but are associated with the library instead of the header file. ^(Cautious +** programmers might include assert() statements in their application to +** verify that values returned by these interfaces match the macros in +** the header, and thus insure that the application is +** compiled with matching library and header files. +** +** 
+** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
+** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
+** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
+**
)^ +** +** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION] +** macro. ^The sqlite3_libversion() function returns a pointer to the +** to the sqlite3_version[] string constant. The sqlite3_libversion() +** function is provided for use in DLLs since DLL users usually do not have +** direct access to string constants within the DLL. ^The +** sqlite3_libversion_number() function returns an integer equal to +** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns +** a pointer to a string constant whose value is the same as the +** [SQLITE_SOURCE_ID] C preprocessor macro. +** +** See also: [sqlite_version()] and [sqlite_source_id()]. +*/ +SQLITE_API SQLITE_EXTERN const char sqlite3_version[]; +SQLITE_API const char *sqlite3_libversion(void); +SQLITE_API const char *sqlite3_sourceid(void); +SQLITE_API int sqlite3_libversion_number(void); + +/* +** CAPI3REF: Run-Time Library Compilation Options Diagnostics +** +** ^The sqlite3_compileoption_used() function returns 0 or 1 +** indicating whether the specified option was defined at +** compile time. ^The SQLITE_ prefix may be omitted from the +** option name passed to sqlite3_compileoption_used(). +** +** ^The sqlite3_compileoption_get() function allows iterating +** over the list of options that were defined at compile time by +** returning the N-th compile time option string. ^If N is out of range, +** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ +** prefix is omitted from any strings returned by +** sqlite3_compileoption_get(). +** +** ^Support for the diagnostic functions sqlite3_compileoption_used() +** and sqlite3_compileoption_get() may be omitted by specifying the +** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. +** +** See also: SQL functions [sqlite_compileoption_used()] and +** [sqlite_compileoption_get()] and the [compile_options pragma]. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_API int sqlite3_compileoption_used(const char *zOptName); +SQLITE_API const char *sqlite3_compileoption_get(int N); +#endif + +/* +** CAPI3REF: Test To See If The Library Is Threadsafe +** +** ^The sqlite3_threadsafe() function returns zero if and only if +** SQLite was compiled with mutexing code omitted due to the +** [SQLITE_THREADSAFE] compile-time option being set to 0. +** +** SQLite can be compiled with or without mutexes. When +** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes +** are enabled and SQLite is threadsafe. When the +** [SQLITE_THREADSAFE] macro is 0, +** the mutexes are omitted. Without the mutexes, it is not safe +** to use SQLite concurrently from more than one thread. +** +** Enabling mutexes incurs a measurable performance penalty. +** So if speed is of utmost importance, it makes sense to disable +** the mutexes. But for maximum safety, mutexes should be enabled. +** ^The default behavior is for mutexes to be enabled. +** +** This interface can be used by an application to make sure that the +** version of SQLite that it is linking against was compiled with +** the desired setting of the [SQLITE_THREADSAFE] macro. +** +** This interface only reports on the compile-time mutex setting +** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with +** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but +** can be fully or partially disabled using a call to [sqlite3_config()] +** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], +** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the +** sqlite3_threadsafe() function shows only the compile-time setting of +** thread safety, not any run-time changes to that setting made by +** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() +** is unchanged by calls to sqlite3_config().)^ +** +** See the [threading mode] documentation for additional information. +*/ +SQLITE_API int sqlite3_threadsafe(void); + +/* +** CAPI3REF: Database Connection Handle +** KEYWORDS: {database connection} {database connections} +** +** Each open SQLite database is represented by a pointer to an instance of +** the opaque structure named "sqlite3". It is useful to think of an sqlite3 +** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and +** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] +** and [sqlite3_close_v2()] are its destructors. There are many other +** interfaces (such as +** [sqlite3_prepare_v2()], [sqlite3_create_function()], and +** [sqlite3_busy_timeout()] to name but three) that are methods on an +** sqlite3 object. +*/ +typedef struct sqlite3 sqlite3; + +/* +** CAPI3REF: 64-Bit Integer Types +** KEYWORDS: sqlite_int64 sqlite_uint64 +** +** Because there is no cross-platform way to specify 64-bit integer types +** SQLite includes typedefs for 64-bit signed and unsigned integers. +** +** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. +** The sqlite_int64 and sqlite_uint64 types are supported for backwards +** compatibility only. +** +** ^The sqlite3_int64 and sqlite_int64 types can store integer values +** between -9223372036854775808 and +9223372036854775807 inclusive. ^The +** sqlite3_uint64 and sqlite_uint64 types can store integer values +** between 0 and +18446744073709551615 inclusive. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif +typedef sqlite_int64 sqlite3_int64; +typedef sqlite_uint64 sqlite3_uint64; + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite3_int64 +#endif + +/* +** CAPI3REF: Closing A Database Connection +** +** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors +** for the [sqlite3] object. +** ^Calls to sqlite3_close() and sqlite3_close_v2() return SQLITE_OK if +** the [sqlite3] object is successfully destroyed and all associated +** resources are deallocated. +** +** ^If the database connection is associated with unfinalized prepared +** statements or unfinished sqlite3_backup objects then sqlite3_close() +** will leave the database connection open and return [SQLITE_BUSY]. +** ^If sqlite3_close_v2() is called with unfinalized prepared statements +** and unfinished sqlite3_backups, then the database connection becomes +** an unusable "zombie" which will automatically be deallocated when the +** last prepared statement is finalized or the last sqlite3_backup is +** finished. The sqlite3_close_v2() interface is intended for use with +** host languages that are garbage collected, and where the order in which +** destructors are called is arbitrary. +** +** Applications should [sqlite3_finalize | finalize] all [prepared statements], +** [sqlite3_blob_close | close] all [BLOB handles], and +** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated +** with the [sqlite3] object prior to attempting to close the object. ^If +** sqlite3_close_v2() is called on a [database connection] that still has +** outstanding [prepared statements], [BLOB handles], and/or +** [sqlite3_backup] objects then it returns SQLITE_OK but the deallocation +** of resources is deferred until all [prepared statements], [BLOB handles], +** and [sqlite3_backup] objects are also destroyed. +** +** ^If an [sqlite3] object is destroyed while a transaction is open, +** the transaction is automatically rolled back. +** +** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)] +** must be either a NULL +** pointer or an [sqlite3] object pointer obtained +** from [sqlite3_open()], [sqlite3_open16()], or +** [sqlite3_open_v2()], and not previously closed. +** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer +** argument is a harmless no-op. +*/ +SQLITE_API int sqlite3_close(sqlite3*); +SQLITE_API int sqlite3_close_v2(sqlite3*); + +/* +** The type for a callback function. +** This is legacy and deprecated. It is included for historical +** compatibility and is not documented. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** CAPI3REF: One-Step Query Execution Interface +** +** The sqlite3_exec() interface is a convenience wrapper around +** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], +** that allows an application to run multiple statements of SQL +** without having to use a lot of C code. +** +** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, +** semicolon-separate SQL statements passed into its 2nd argument, +** in the context of the [database connection] passed in as its 1st +** argument. ^If the callback function of the 3rd argument to +** sqlite3_exec() is not NULL, then it is invoked for each result row +** coming out of the evaluated SQL statements. ^The 4th argument to +** sqlite3_exec() is relayed through to the 1st argument of each +** callback invocation. ^If the callback pointer to sqlite3_exec() +** is NULL, then no callback is ever invoked and result rows are +** ignored. +** +** ^If an error occurs while evaluating the SQL statements passed into +** sqlite3_exec(), then execution of the current statement stops and +** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() +** is not NULL then any error message is written into memory obtained +** from [sqlite3_malloc()] and passed back through the 5th parameter. +** To avoid memory leaks, the application should invoke [sqlite3_free()] +** on error message strings returned through the 5th parameter of +** of sqlite3_exec() after the error message string is no longer needed. +** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors +** occur, then sqlite3_exec() sets the pointer in its 5th parameter to +** NULL before returning. +** +** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() +** routine returns SQLITE_ABORT without invoking the callback again and +** without running any subsequent SQL statements. +** +** ^The 2nd argument to the sqlite3_exec() callback function is the +** number of columns in the result. ^The 3rd argument to the sqlite3_exec() +** callback is an array of pointers to strings obtained as if from +** [sqlite3_column_text()], one for each column. ^If an element of a +** result row is NULL then the corresponding string pointer for the +** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the +** sqlite3_exec() callback is an array of pointers to strings where each +** entry represents the name of corresponding result column as obtained +** from [sqlite3_column_name()]. +** +** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer +** to an empty string, or a pointer that contains only whitespace and/or +** SQL comments, then no SQL statements are evaluated and the database +** is not changed. +** +** Restrictions: +** +**
    +**
  • The application must insure that the 1st parameter to sqlite3_exec() +** is a valid and open [database connection]. +**
  • The application must not close [database connection] specified by +** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. +**
  • The application must not modify the SQL statement text passed into +** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. +**
+*/ +SQLITE_API int sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be evaluated */ + int (*callback)(void*,int,char**,char**), /* Callback function */ + void *, /* 1st argument to callback */ + char **errmsg /* Error msg written here */ +); + +/* +** CAPI3REF: Result Codes +** KEYWORDS: SQLITE_OK {error code} {error codes} +** KEYWORDS: {result code} {result codes} +** +** Many SQLite functions return an integer result code from the set shown +** here in order to indicate success or failure. +** +** New error codes may be added in future versions of SQLite. +** +** See also: [SQLITE_IOERR_READ | extended result codes], +** [sqlite3_vtab_on_conflict()] [SQLITE_ROLLBACK | result codes]. +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ +#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** CAPI3REF: Extended Result Codes +** KEYWORDS: {extended error code} {extended error codes} +** KEYWORDS: {extended result code} {extended result codes} +** +** In its default configuration, SQLite API routines return one of 26 integer +** [SQLITE_OK | result codes]. However, experience has shown that many of +** these result codes are too coarse-grained. They do not provide as +** much information about problems as programmers might like. In an effort to +** address this, newer versions of SQLite (version 3.3.8 and later) include +** support for additional result codes that provide more detailed information +** about errors. The extended result codes are enabled or disabled +** on a per database connection basis using the +** [sqlite3_extended_result_codes()] API. +** +** Some of the available extended result codes are listed here. +** One may expect the number of extended result codes will be expand +** over time. Software that uses extended result codes should expect +** to see new result codes in future releases of SQLite. +** +** The SQLITE_OK result code will never be extended. It will always +** be exactly zero. +*/ +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) +#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) +#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) +#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) +#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) +#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) +#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) +#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) +#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) +#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) +#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) +#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) +#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) +#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) +#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) +#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) +#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) +#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) +#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) +#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) +#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) +#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) +#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) +#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) +#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) +#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) +#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) +#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) +#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) +#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) +#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) +#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) +#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) +#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) + +/* +** CAPI3REF: Flags For File Open Operations +** +** These bit values are intended for use in the +** 3rd parameter to the [sqlite3_open_v2()] interface and +** in the 4th parameter to the [sqlite3_vfs.xOpen] method. +*/ +#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ +#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ +#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ +#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ +#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ +#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ +#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ +#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ +#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ +#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ +#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ + +/* Reserved: 0x00F00000 */ + +/* +** CAPI3REF: Device Characteristics +** +** The xDeviceCharacteristics method of the [sqlite3_io_methods] +** object returns an integer which is a vector of these +** bit values expressing I/O characteristics of the mass storage +** device that holds the file that the [sqlite3_io_methods] +** refers to. +** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +** after reboot following a crash or power loss, the only bytes in a +** file that were written at the application level might have changed +** and that adjacent bytes, even bytes within the same sector are +** guaranteed to be unchanged. +*/ +#define SQLITE_IOCAP_ATOMIC 0x00000001 +#define SQLITE_IOCAP_ATOMIC512 0x00000002 +#define SQLITE_IOCAP_ATOMIC1K 0x00000004 +#define SQLITE_IOCAP_ATOMIC2K 0x00000008 +#define SQLITE_IOCAP_ATOMIC4K 0x00000010 +#define SQLITE_IOCAP_ATOMIC8K 0x00000020 +#define SQLITE_IOCAP_ATOMIC16K 0x00000040 +#define SQLITE_IOCAP_ATOMIC32K 0x00000080 +#define SQLITE_IOCAP_ATOMIC64K 0x00000100 +#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 +#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 +#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 +#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 + +/* +** CAPI3REF: File Locking Levels +** +** SQLite uses one of these integer values as the second +** argument to calls it makes to the xLock() and xUnlock() methods +** of an [sqlite3_io_methods] object. +*/ +#define SQLITE_LOCK_NONE 0 +#define SQLITE_LOCK_SHARED 1 +#define SQLITE_LOCK_RESERVED 2 +#define SQLITE_LOCK_PENDING 3 +#define SQLITE_LOCK_EXCLUSIVE 4 + +/* +** CAPI3REF: Synchronization Type Flags +** +** When SQLite invokes the xSync() method of an +** [sqlite3_io_methods] object it uses a combination of +** these integer values as the second argument. +** +** When the SQLITE_SYNC_DATAONLY flag is used, it means that the +** sync operation only needs to flush data to mass storage. Inode +** information need not be flushed. If the lower four bits of the flag +** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. +** If the lower four bits equal SQLITE_SYNC_FULL, that means +** to use Mac OS X style fullsync instead of fsync(). +** +** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +** settings. The [synchronous pragma] determines when calls to the +** xSync VFS method occur and applies uniformly across all platforms. +** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +** energetic or rigorous or forceful the sync operations are and +** only make a difference on Mac OSX for the default SQLite code. +** (Third-party VFS implementations might also make the distinction +** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +** operating systems natively supported by SQLite, only Mac OSX +** cares about the difference.) +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + +/* +** CAPI3REF: OS Interface Open File Handle +** +** An [sqlite3_file] object represents an open file in the +** [sqlite3_vfs | OS interface layer]. Individual OS interface +** implementations will +** want to subclass this object by appending additional fields +** for their own use. The pMethods entry is a pointer to an +** [sqlite3_io_methods] object that defines methods for performing +** I/O operations on the open file. +*/ +typedef struct sqlite3_file sqlite3_file; +struct sqlite3_file { + const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ +}; + +/* +** CAPI3REF: OS Interface File Virtual Methods Object +** +** Every file opened by the [sqlite3_vfs.xOpen] method populates an +** [sqlite3_file] object (or, more commonly, a subclass of the +** [sqlite3_file] object) with a pointer to an instance of this object. +** This object defines the methods used to perform various operations +** against the open file represented by the [sqlite3_file] object. +** +** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element +** to a non-NULL pointer, then the sqlite3_io_methods.xClose method +** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The +** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] +** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element +** to NULL. +** +** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] +** flag may be ORed in to indicate that only the data of the file +** and not its inode needs to be synced. +** +** The integer values to xLock() and xUnlock() are one of +**
    +**
  • [SQLITE_LOCK_NONE], +**
  • [SQLITE_LOCK_SHARED], +**
  • [SQLITE_LOCK_RESERVED], +**
  • [SQLITE_LOCK_PENDING], or +**
  • [SQLITE_LOCK_EXCLUSIVE]. +**
+** xLock() increases the lock. xUnlock() decreases the lock. +** The xCheckReservedLock() method checks whether any database connection, +** either in this process or in some other process, is holding a RESERVED, +** PENDING, or EXCLUSIVE lock on the file. It returns true +** if such a lock exists and false otherwise. +** +** The xFileControl() method is a generic interface that allows custom +** VFS implementations to directly control an open file using the +** [sqlite3_file_control()] interface. The second "op" argument is an +** integer opcode. The third argument is a generic pointer intended to +** point to a structure that may contain arguments or space in which to +** write return values. Potential uses for xFileControl() might be +** functions to enable blocking locks with timeouts, to change the +** locking strategy (for example to use dot-file locks), to inquire +** about the status of a lock, or to break stale locks. The SQLite +** core reserves all opcodes less than 100 for its own use. +** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. VFS implementations should +** return [SQLITE_NOTFOUND] for file control opcodes that they do not +** recognize. +** +** The xSectorSize() method returns the sector size of the +** device that underlies the file. The sector size is the +** minimum write that can be performed without disturbing +** other bytes in the file. The xDeviceCharacteristics() +** method returns a bit vector describing behaviors of the +** underlying device: +** +**
    +**
  • [SQLITE_IOCAP_ATOMIC] +**
  • [SQLITE_IOCAP_ATOMIC512] +**
  • [SQLITE_IOCAP_ATOMIC1K] +**
  • [SQLITE_IOCAP_ATOMIC2K] +**
  • [SQLITE_IOCAP_ATOMIC4K] +**
  • [SQLITE_IOCAP_ATOMIC8K] +**
  • [SQLITE_IOCAP_ATOMIC16K] +**
  • [SQLITE_IOCAP_ATOMIC32K] +**
  • [SQLITE_IOCAP_ATOMIC64K] +**
  • [SQLITE_IOCAP_SAFE_APPEND] +**
  • [SQLITE_IOCAP_SEQUENTIAL] +**
+** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +** +** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill +** in the unread portions of the buffer with zeros. A VFS that +** fails to zero-fill short reads might seem to work. However, +** failure to zero-fill short reads will eventually lead to +** database corruption. +*/ +typedef struct sqlite3_io_methods sqlite3_io_methods; +struct sqlite3_io_methods { + int iVersion; + int (*xClose)(sqlite3_file*); + int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); + int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); + int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); + int (*xSync)(sqlite3_file*, int flags); + int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); + int (*xLock)(sqlite3_file*, int); + int (*xUnlock)(sqlite3_file*, int); + int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); + int (*xFileControl)(sqlite3_file*, int op, void *pArg); + int (*xSectorSize)(sqlite3_file*); + int (*xDeviceCharacteristics)(sqlite3_file*); + /* Methods above are valid for version 1 */ + int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**); + int (*xShmLock)(sqlite3_file*, int offset, int n, int flags); + void (*xShmBarrier)(sqlite3_file*); + int (*xShmUnmap)(sqlite3_file*, int deleteFlag); + /* Methods above are valid for version 2 */ + /* Additional methods may be added in future releases */ +}; + +/* +** CAPI3REF: Standard File Control Opcodes +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] +** interface. +** +** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This +** opcode causes the xFileControl method to write the current state of +** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], +** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) +** into an integer that the pArg argument points to. This capability +** is used during testing and only needs to be supported when SQLITE_TEST +** is defined. +**
    +**
  • [[SQLITE_FCNTL_SIZE_HINT]] +** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS +** layer a hint of how large the database file will grow to be during the +** current transaction. This hint is not guaranteed to be accurate but it +** is often close. The underlying VFS might choose to preallocate database +** file space based on this hint in order to help writes to the database +** file run faster. +** +**
  • [[SQLITE_FCNTL_CHUNK_SIZE]] +** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS +** extends and truncates the database file in chunks of a size specified +** by the user. The fourth argument to [sqlite3_file_control()] should +** point to an integer (type int) containing the new chunk-size to use +** for the nominated database. Allocating database file space in large +** chunks (say 1MB at a time), may reduce file-system fragmentation and +** improve performance on some systems. +** +**
  • [[SQLITE_FCNTL_FILE_POINTER]] +** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer +** to the [sqlite3_file] object associated with a particular database +** connection. See the [sqlite3_file_control()] documentation for +** additional information. +** +**
  • [[SQLITE_FCNTL_SYNC_OMITTED]] +** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by +** SQLite and sent to all VFSes in place of a call to the xSync method +** when the database connection has [PRAGMA synchronous] set to OFF.)^ +** Some specialized VFSes need this signal in order to operate correctly +** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most +** VFSes do not need this signal and should silently ignore this opcode. +** Applications should not call [sqlite3_file_control()] with this +** opcode as doing so may disrupt the operation of the specialized VFSes +** that do require it. +** +**
  • [[SQLITE_FCNTL_WIN32_AV_RETRY]] +** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic +** retry counts and intervals for certain disk I/O operations for the +** windows [VFS] in order to provide robustness in the presence of +** anti-virus programs. By default, the windows VFS will retry file read, +** file write, and file delete operations up to 10 times, with a delay +** of 25 milliseconds before the first retry and with the delay increasing +** by an additional 25 milliseconds with each subsequent retry. This +** opcode allows these two values (10 retries and 25 milliseconds of delay) +** to be adjusted. The values are changed for all database connections +** within the same process. The argument is a pointer to an array of two +** integers where the first integer i the new retry count and the second +** integer is the delay. If either integer is negative, then the setting +** is not changed but instead the prior value of that setting is written +** into the array entry, allowing the current retry settings to be +** interrogated. The zDbName parameter is ignored. +** +**
  • [[SQLITE_FCNTL_PERSIST_WAL]] +** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the +** persistent [WAL | Write Ahead Log] setting. By default, the auxiliary +** write ahead log and shared memory files used for transaction control +** are automatically deleted when the latest connection to the database +** closes. Setting persistent WAL mode causes those files to persist after +** close. Persisting the files is useful when other processes that do not +** have write permission on the directory containing the database file want +** to read the database file, as the WAL and shared memory files must exist +** in order for the database to be readable. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable persistent WAL mode or 1 to enable persistent +** WAL mode. If the integer is -1, then it is overwritten with the current +** WAL persistence setting. +** +**
  • [[SQLITE_FCNTL_POWERSAFE_OVERWRITE]] +** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the +** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting +** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the +** xDeviceCharacteristics methods. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage +** mode. If the integer is -1, then it is overwritten with the current +** zero-damage mode setting. +** +**
  • [[SQLITE_FCNTL_OVERWRITE]] +** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening +** a write transaction to indicate that, unless it is rolled back for some +** reason, the entire database file will be overwritten by the current +** transaction. This is used by VACUUM operations. +** +**
  • [[SQLITE_FCNTL_VFSNAME]] +** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of +** all [VFSes] in the VFS stack. The names are of all VFS shims and the +** final bottom-level VFS are written into memory obtained from +** [sqlite3_malloc()] and the result is stored in the char* variable +** that the fourth parameter of [sqlite3_file_control()] points to. +** The caller is responsible for freeing the memory when done. As with +** all file-control actions, there is no guarantee that this will actually +** do anything. Callers should initialize the char* variable to a NULL +** pointer in case this file-control is not implemented. This file-control +** is intended for diagnostic use only. +** +**
  • [[SQLITE_FCNTL_PRAGMA]] +** ^Whenever a [PRAGMA] statement is parsed, an [SQLITE_FCNTL_PRAGMA] +** file control is sent to the open [sqlite3_file] object corresponding +** to the database file to which the pragma statement refers. ^The argument +** to the [SQLITE_FCNTL_PRAGMA] file control is an array of +** pointers to strings (char**) in which the second element of the array +** is the name of the pragma and the third element is the argument to the +** pragma or NULL if the pragma has no argument. ^The handler for an +** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element +** of the char** argument point to a string obtained from [sqlite3_mprintf()] +** or the equivalent and that string will become the result of the pragma or +** the error message if the pragma fails. ^If the +** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal +** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] +** file control returns [SQLITE_OK], then the parser assumes that the +** VFS has handled the PRAGMA itself and the parser generates a no-op +** prepared statement. ^If the [SQLITE_FCNTL_PRAGMA] file control returns +** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means +** that the VFS encountered an error while handling the [PRAGMA] and the +** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] +** file control occurs at the beginning of pragma statement analysis and so +** it is able to override built-in [PRAGMA] statements. +** +**
  • [[SQLITE_FCNTL_BUSYHANDLER]] +** ^This file-control may be invoked by SQLite on the database file handle +** shortly after it is opened in order to provide a custom VFS with access +** to the connections busy-handler callback. The argument is of type (void **) +** - an array of two (void *) values. The first (void *) actually points +** to a function of type (int (*)(void *)). In order to invoke the connections +** busy-handler, this function should be invoked with the second (void *) in +** the array as the only argument. If it returns non-zero, then the operation +** should be retried. If it returns zero, the custom VFS should abandon the +** current operation. +** +**
  • [[SQLITE_FCNTL_TEMPFILENAME]] +** ^Application can invoke this file-control to have SQLite generate a +** temporary filename using the same algorithm that is followed to generate +** temporary filenames for TEMP tables and other internal uses. The +** argument should be a char** which will be filled with the filename +** written into memory obtained from [sqlite3_malloc()]. The caller should +** invoke [sqlite3_free()] on the result to avoid a memory leak. +** +**
+*/ +#define SQLITE_FCNTL_LOCKSTATE 1 +#define SQLITE_GET_LOCKPROXYFILE 2 +#define SQLITE_SET_LOCKPROXYFILE 3 +#define SQLITE_LAST_ERRNO 4 +#define SQLITE_FCNTL_SIZE_HINT 5 +#define SQLITE_FCNTL_CHUNK_SIZE 6 +#define SQLITE_FCNTL_FILE_POINTER 7 +#define SQLITE_FCNTL_SYNC_OMITTED 8 +#define SQLITE_FCNTL_WIN32_AV_RETRY 9 +#define SQLITE_FCNTL_PERSIST_WAL 10 +#define SQLITE_FCNTL_OVERWRITE 11 +#define SQLITE_FCNTL_VFSNAME 12 +#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 +#define SQLITE_FCNTL_PRAGMA 14 +#define SQLITE_FCNTL_BUSYHANDLER 15 +#define SQLITE_FCNTL_TEMPFILENAME 16 + +/* +** CAPI3REF: Mutex Handle +** +** The mutex module within SQLite defines [sqlite3_mutex] to be an +** abstract type for a mutex object. The SQLite core never looks +** at the internal representation of an [sqlite3_mutex]. It only +** deals with pointers to the [sqlite3_mutex] object. +** +** Mutexes are created using [sqlite3_mutex_alloc()]. +*/ +typedef struct sqlite3_mutex sqlite3_mutex; + +/* +** CAPI3REF: OS Interface Object +** +** An instance of the sqlite3_vfs object defines the interface between +** the SQLite core and the underlying operating system. The "vfs" +** in the name of the object stands for "virtual file system". See +** the [VFS | VFS documentation] for further information. +** +** The value of the iVersion field is initially 1 but may be larger in +** future versions of SQLite. Additional fields may be appended to this +** object when the iVersion value is increased. Note that the structure +** of the sqlite3_vfs object changes in the transaction between +** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not +** modified. +** +** The szOsFile field is the size of the subclassed [sqlite3_file] +** structure used by this VFS. mxPathname is the maximum length of +** a pathname in this VFS. +** +** Registered sqlite3_vfs objects are kept on a linked list formed by +** the pNext pointer. The [sqlite3_vfs_register()] +** and [sqlite3_vfs_unregister()] interfaces manage this list +** in a thread-safe way. The [sqlite3_vfs_find()] interface +** searches the list. Neither the application code nor the VFS +** implementation should use the pNext pointer. +** +** The pNext field is the only field in the sqlite3_vfs +** structure that SQLite will ever modify. SQLite will only access +** or modify this field while holding a particular static mutex. +** The application should never modify anything within the sqlite3_vfs +** object once the object has been registered. +** +** The zName field holds the name of the VFS module. The name must +** be unique across all VFS modules. +** +** [[sqlite3_vfs.xOpen]] +** ^SQLite guarantees that the zFilename parameter to xOpen +** is either a NULL pointer or string obtained +** from xFullPathname() with an optional suffix added. +** ^If a suffix is added to the zFilename parameter, it will +** consist of a single "-" character followed by no more than +** 11 alphanumeric and/or "-" characters. +** ^SQLite further guarantees that +** the string will be valid and unchanged until xClose() is +** called. Because of the previous sentence, +** the [sqlite3_file] can safely store a pointer to the +** filename if it needs to remember the filename for some reason. +** If the zFilename parameter to xOpen is a NULL pointer then xOpen +** must invent its own temporary name for the file. ^Whenever the +** xFilename parameter is NULL it will also be the case that the +** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. +** +** The flags argument to xOpen() includes all bits set in +** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +** or [sqlite3_open16()] is used, then flags includes at least +** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. +** If xOpen() opens a file read-only then it sets *pOutFlags to +** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. +** +** ^(SQLite will also add one of the following flags to the xOpen() +** call, depending on the object being opened: +** +**
    +**
  • [SQLITE_OPEN_MAIN_DB] +**
  • [SQLITE_OPEN_MAIN_JOURNAL] +**
  • [SQLITE_OPEN_TEMP_DB] +**
  • [SQLITE_OPEN_TEMP_JOURNAL] +**
  • [SQLITE_OPEN_TRANSIENT_DB] +**
  • [SQLITE_OPEN_SUBJOURNAL] +**
  • [SQLITE_OPEN_MASTER_JOURNAL] +**
  • [SQLITE_OPEN_WAL] +**
)^ +** +** The file I/O implementation can use the object type flags to +** change the way it deals with files. For example, an application +** that does not care about crash recovery or rollback might make +** the open of a journal file a no-op. Writes to this journal would +** also be no-ops, and any attempt to read the journal would return +** SQLITE_IOERR. Or the implementation might recognize that a database +** file will be doing page-aligned sector reads and writes in a random +** order and set up its I/O subsystem accordingly. +** +** SQLite might also add one of the following flags to the xOpen method: +** +**
    +**
  • [SQLITE_OPEN_DELETEONCLOSE] +**
  • [SQLITE_OPEN_EXCLUSIVE] +**
+** +** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE] +** will be set for TEMP databases and their journals, transient +** databases, and subjournals. +** +** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction +** with the [SQLITE_OPEN_CREATE] flag, which are both directly +** analogous to the O_EXCL and O_CREAT flags of the POSIX open() +** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the +** SQLITE_OPEN_CREATE, is used to indicate that file should always +** be created, and that it is an error if it already exists. +** It is not used to indicate the file should be opened +** for exclusive access. +** +** ^At least szOsFile bytes of memory are allocated by SQLite +** to hold the [sqlite3_file] structure passed as the third +** argument to xOpen. The xOpen method does not have to +** allocate the structure; it should just fill it in. Note that +** the xOpen method must set the sqlite3_file.pMethods to either +** a valid [sqlite3_io_methods] object or to NULL. xOpen must do +** this even if the open fails. SQLite expects that the sqlite3_file.pMethods +** element will be valid after xOpen returns regardless of the success +** or failure of the xOpen call. +** +** [[sqlite3_vfs.xAccess]] +** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to +** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] +** to test whether a file is at least readable. The file can be a +** directory. +** +** ^SQLite will always allocate at least mxPathname+1 bytes for the +** output buffer xFullPathname. The exact size of the output buffer +** is also passed as a parameter to both methods. If the output buffer +** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is +** handled as a fatal error by SQLite, vfs implementations should endeavor +** to prevent this by setting mxPathname to a sufficiently large value. +** +** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64() +** interfaces are not strictly a part of the filesystem, but they are +** included in the VFS structure for completeness. +** The xRandomness() function attempts to return nBytes bytes +** of good-quality randomness into zOut. The return value is +** the actual number of bytes of randomness obtained. +** The xSleep() method causes the calling thread to sleep for at +** least the number of microseconds given. ^The xCurrentTime() +** method returns a Julian Day Number for the current date and time as +** a floating point value. +** ^The xCurrentTimeInt64() method returns, as an integer, the Julian +** Day Number multiplied by 86400000 (the number of milliseconds in +** a 24-hour day). +** ^SQLite will use the xCurrentTimeInt64() method to get the current +** date and time if that method is available (if iVersion is 2 or +** greater and the function pointer is not NULL) and will fall back +** to xCurrentTime() if xCurrentTimeInt64() is unavailable. +** +** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces +** are not used by the SQLite core. These optional interfaces are provided +** by some VFSes to facilitate testing of the VFS code. By overriding +** system calls with functions under its control, a test program can +** simulate faults and error conditions that would otherwise be difficult +** or impossible to induce. The set of system calls that can be overridden +** varies from one VFS to another, and from one version of the same VFS to the +** next. Applications that use these interfaces must be prepared for any +** or all of these interfaces to be NULL or for their behavior to change +** from one release to the next. Applications must not attempt to access +** any of these methods if the iVersion of the VFS is less than 3. +*/ +typedef struct sqlite3_vfs sqlite3_vfs; +typedef void (*sqlite3_syscall_ptr)(void); +struct sqlite3_vfs { + int iVersion; /* Structure version number (currently 3) */ + int szOsFile; /* Size of subclassed sqlite3_file */ + int mxPathname; /* Maximum file pathname length */ + sqlite3_vfs *pNext; /* Next registered VFS */ + const char *zName; /* Name of this virtual file system */ + void *pAppData; /* Pointer to application-specific data */ + int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, + int flags, int *pOutFlags); + int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); + int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); + int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); + void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); + void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); + void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); + void (*xDlClose)(sqlite3_vfs*, void*); + int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); + int (*xSleep)(sqlite3_vfs*, int microseconds); + int (*xCurrentTime)(sqlite3_vfs*, double*); + int (*xGetLastError)(sqlite3_vfs*, int, char *); + /* + ** The methods above are in version 1 of the sqlite_vfs object + ** definition. Those that follow are added in version 2 or later + */ + int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*); + /* + ** The methods above are in versions 1 and 2 of the sqlite_vfs object. + ** Those below are for version 3 and greater. + */ + int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr); + sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName); + const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName); + /* + ** The methods above are in versions 1 through 3 of the sqlite_vfs object. + ** New fields may be appended in figure versions. The iVersion + ** value will increment whenever this happens. + */ +}; + +/* +** CAPI3REF: Flags for the xAccess VFS method +** +** These integer constants can be used as the third parameter to +** the xAccess method of an [sqlite3_vfs] object. They determine +** what kind of permissions the xAccess method is looking for. +** With SQLITE_ACCESS_EXISTS, the xAccess method +** simply checks whether the file exists. +** With SQLITE_ACCESS_READWRITE, the xAccess method +** checks whether the named directory is both readable and writable +** (in other words, if files can be added, removed, and renamed within +** the directory). +** The SQLITE_ACCESS_READWRITE constant is currently used only by the +** [temp_store_directory pragma], though this could change in a future +** release of SQLite. +** With SQLITE_ACCESS_READ, the xAccess method +** checks whether the file is readable. The SQLITE_ACCESS_READ constant is +** currently unused, though it might be used in a future release of +** SQLite. +*/ +#define SQLITE_ACCESS_EXISTS 0 +#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */ +#define SQLITE_ACCESS_READ 2 /* Unused */ + +/* +** CAPI3REF: Flags for the xShmLock VFS method +** +** These integer constants define the various locking operations +** allowed by the xShmLock method of [sqlite3_io_methods]. The +** following are the only legal combinations of flags to the +** xShmLock method: +** +**
    +**
  • SQLITE_SHM_LOCK | SQLITE_SHM_SHARED +**
  • SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE +**
  • SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED +**
  • SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE +**
+** +** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as +** was given no the corresponding lock. +** +** The xShmLock method can transition between unlocked and SHARED or +** between unlocked and EXCLUSIVE. It cannot transition between SHARED +** and EXCLUSIVE. +*/ +#define SQLITE_SHM_UNLOCK 1 +#define SQLITE_SHM_LOCK 2 +#define SQLITE_SHM_SHARED 4 +#define SQLITE_SHM_EXCLUSIVE 8 + +/* +** CAPI3REF: Maximum xShmLock index +** +** The xShmLock method on [sqlite3_io_methods] may use values +** between 0 and this upper bound as its "offset" argument. +** The SQLite core will never attempt to acquire or release a +** lock outside of this range +*/ +#define SQLITE_SHM_NLOCK 8 + + +/* +** CAPI3REF: Initialize The SQLite Library +** +** ^The sqlite3_initialize() routine initializes the +** SQLite library. ^The sqlite3_shutdown() routine +** deallocates any resources that were allocated by sqlite3_initialize(). +** These routines are designed to aid in process initialization and +** shutdown on embedded systems. Workstation applications using +** SQLite normally do not need to invoke either of these routines. +** +** A call to sqlite3_initialize() is an "effective" call if it is +** the first time sqlite3_initialize() is invoked during the lifetime of +** the process, or if it is the first time sqlite3_initialize() is invoked +** following a call to sqlite3_shutdown(). ^(Only an effective call +** of sqlite3_initialize() does any initialization. All other calls +** are harmless no-ops.)^ +** +** A call to sqlite3_shutdown() is an "effective" call if it is the first +** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only +** an effective call to sqlite3_shutdown() does any deinitialization. +** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^ +** +** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown() +** is not. The sqlite3_shutdown() interface must only be called from a +** single thread. All open [database connections] must be closed and all +** other SQLite resources must be deallocated prior to invoking +** sqlite3_shutdown(). +** +** Among other things, ^sqlite3_initialize() will invoke +** sqlite3_os_init(). Similarly, ^sqlite3_shutdown() +** will invoke sqlite3_os_end(). +** +** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success. +** ^If for some reason, sqlite3_initialize() is unable to initialize +** the library (perhaps it is unable to allocate a needed resource such +** as a mutex) it returns an [error code] other than [SQLITE_OK]. +** +** ^The sqlite3_initialize() routine is called internally by many other +** SQLite interfaces so that an application usually does not need to +** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] +** calls sqlite3_initialize() so the SQLite library will be automatically +** initialized when [sqlite3_open()] is called if it has not be initialized +** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT] +** compile-time option, then the automatic calls to sqlite3_initialize() +** are omitted and the application must call sqlite3_initialize() directly +** prior to using any other SQLite interface. For maximum portability, +** it is recommended that applications always invoke sqlite3_initialize() +** directly prior to using any other SQLite interface. Future releases +** of SQLite may require this. In other words, the behavior exhibited +** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the +** default behavior in some future release of SQLite. +** +** The sqlite3_os_init() routine does operating-system specific +** initialization of the SQLite library. The sqlite3_os_end() +** routine undoes the effect of sqlite3_os_init(). Typical tasks +** performed by these routines include allocation or deallocation +** of static resources, initialization of global variables, +** setting up a default [sqlite3_vfs] module, or setting up +** a default configuration using [sqlite3_config()]. +** +** The application should never invoke either sqlite3_os_init() +** or sqlite3_os_end() directly. The application should only invoke +** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() +** interface is called automatically by sqlite3_initialize() and +** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate +** implementations for sqlite3_os_init() and sqlite3_os_end() +** are built into SQLite when it is compiled for Unix, Windows, or OS/2. +** When [custom builds | built for other platforms] +** (using the [SQLITE_OS_OTHER=1] compile-time +** option) the application must supply a suitable implementation for +** sqlite3_os_init() and sqlite3_os_end(). An application-supplied +** implementation of sqlite3_os_init() or sqlite3_os_end() +** must return [SQLITE_OK] on success and some other [error code] upon +** failure. +*/ +SQLITE_API int sqlite3_initialize(void); +SQLITE_API int sqlite3_shutdown(void); +SQLITE_API int sqlite3_os_init(void); +SQLITE_API int sqlite3_os_end(void); + +/* +** CAPI3REF: Configuring The SQLite Library +** +** The sqlite3_config() interface is used to make global configuration +** changes to SQLite in order to tune SQLite to the specific needs of +** the application. The default configuration is recommended for most +** applications and so this routine is usually not necessary. It is +** provided to support rare applications with unusual needs. +** +** The sqlite3_config() interface is not threadsafe. The application +** must insure that no other SQLite interfaces are invoked by other +** threads while sqlite3_config() is running. Furthermore, sqlite3_config() +** may only be invoked prior to library initialization using +** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. +** ^If sqlite3_config() is called after [sqlite3_initialize()] and before +** [sqlite3_shutdown()] then it will return SQLITE_MISUSE. +** Note, however, that ^sqlite3_config() can be called as part of the +** implementation of an application-defined [sqlite3_os_init()]. +** +** The first argument to sqlite3_config() is an integer +** [configuration option] that determines +** what property of SQLite is to be configured. Subsequent arguments +** vary depending on the [configuration option] +** in the first argument. +** +** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. +** ^If the option is unknown or SQLite is unable to set the option +** then this routine returns a non-zero [error code]. +*/ +SQLITE_API int sqlite3_config(int, ...); + +/* +** CAPI3REF: Configure database connections +** +** The sqlite3_db_config() interface is used to make configuration +** changes to a [database connection]. The interface is similar to +** [sqlite3_config()] except that the changes apply to a single +** [database connection] (specified in the first argument). +** +** The second argument to sqlite3_db_config(D,V,...) is the +** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code +** that indicates what aspect of the [database connection] is being configured. +** Subsequent arguments vary depending on the configuration verb. +** +** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if +** the call is considered successful. +*/ +SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Memory Allocation Routines +** +** An instance of this object defines the interface between SQLite +** and low-level memory allocation routines. +** +** This object is used in only one place in the SQLite interface. +** A pointer to an instance of this object is the argument to +** [sqlite3_config()] when the configuration option is +** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. +** By creating an instance of this object +** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) +** during configuration, an application can specify an alternative +** memory allocation subsystem for SQLite to use for all of its +** dynamic memory needs. +** +** Note that SQLite comes with several [built-in memory allocators] +** that are perfectly adequate for the overwhelming majority of applications +** and that this object is only useful to a tiny minority of applications +** with specialized memory allocation requirements. This object is +** also used during testing of SQLite in order to specify an alternative +** memory allocator that simulates memory out-of-memory conditions in +** order to verify that SQLite recovers gracefully from such +** conditions. +** +** The xMalloc, xRealloc, and xFree methods must work like the +** malloc(), realloc() and free() functions from the standard C library. +** ^SQLite guarantees that the second argument to +** xRealloc is always a value returned by a prior call to xRoundup. +** +** xSize should return the allocated size of a memory allocation +** previously obtained from xMalloc or xRealloc. The allocated size +** is always at least as big as the requested size but may be larger. +** +** The xRoundup method returns what would be the allocated size of +** a memory allocation given a particular requested size. Most memory +** allocators round up memory allocations at least to the next multiple +** of 8. Some allocators round up to a larger multiple or to a power of 2. +** Every memory allocation request coming in through [sqlite3_malloc()] +** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, +** that causes the corresponding memory allocation to fail. +** +** The xInit method initializes the memory allocator. (For example, +** it might allocate any require mutexes or initialize internal data +** structures. The xShutdown method is invoked (indirectly) by +** [sqlite3_shutdown()] and should deallocate any resources acquired +** by xInit. The pAppData pointer is used as the only parameter to +** xInit and xShutdown. +** +** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes +** the xInit method, so the xInit method need not be threadsafe. The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. For all other methods, SQLite +** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the +** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which +** it is by default) and so the methods are automatically serialized. +** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other +** methods must be threadsafe or else make their own arrangements for +** serialization. +** +** SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +*/ +typedef struct sqlite3_mem_methods sqlite3_mem_methods; +struct sqlite3_mem_methods { + void *(*xMalloc)(int); /* Memory allocation function */ + void (*xFree)(void*); /* Free a prior allocation */ + void *(*xRealloc)(void*,int); /* Resize an allocation */ + int (*xSize)(void*); /* Return the size of an allocation */ + int (*xRoundup)(int); /* Round up request size to allocation size */ + int (*xInit)(void*); /* Initialize the memory allocator */ + void (*xShutdown)(void*); /* Deinitialize the memory allocator */ + void *pAppData; /* Argument to xInit() and xShutdown() */ +}; + +/* +** CAPI3REF: Configuration Options +** KEYWORDS: {configuration option} +** +** These constants are the available integer configuration options that +** can be passed as the first argument to the [sqlite3_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_config()] to make sure that +** the call worked. The [sqlite3_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+** [[SQLITE_CONFIG_SINGLETHREAD]]
SQLITE_CONFIG_SINGLETHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Single-thread. In other words, it disables +** all mutexing and puts SQLite into a mode where it can only be used +** by a single thread. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to change the [threading mode] from its default +** value of Single-thread and so [sqlite3_config()] will return +** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD +** configuration option.
+** +** [[SQLITE_CONFIG_MULTITHREAD]]
SQLITE_CONFIG_MULTITHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Multi-thread. In other words, it disables +** mutexing on [database connection] and [prepared statement] objects. +** The application is responsible for serializing access to +** [database connections] and [prepared statements]. But other mutexes +** are enabled so that SQLite will be safe to use in a multi-threaded +** environment as long as no two threads attempt to use the same +** [database connection] at the same time. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Multi-thread [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_MULTITHREAD configuration option.
+** +** [[SQLITE_CONFIG_SERIALIZED]]
SQLITE_CONFIG_SERIALIZED
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Serialized. In other words, this option enables +** all mutexes including the recursive +** mutexes on [database connection] and [prepared statement] objects. +** In this mode (which is the default when SQLite is compiled with +** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access +** to [database connections] and [prepared statements] so that the +** application is free to use the same [database connection] or the +** same [prepared statement] in different threads at the same time. +** ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Serialized [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_SERIALIZED configuration option.
+** +** [[SQLITE_CONFIG_MALLOC]]
SQLITE_CONFIG_MALLOC
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mem_methods] structure. The argument specifies +** alternative low-level memory allocation routines to be used in place of +** the memory allocation routines built into SQLite.)^ ^SQLite makes +** its own private copy of the content of the [sqlite3_mem_methods] structure +** before the [sqlite3_config()] call returns.
+** +** [[SQLITE_CONFIG_GETMALLOC]]
SQLITE_CONFIG_GETMALLOC
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods] +** structure is filled with the currently defined memory allocation routines.)^ +** This option can be used to overload the default memory allocation +** routines with a wrapper that simulations memory allocation failure or +** tracks memory usage, for example.
+** +** [[SQLITE_CONFIG_MEMSTATUS]]
SQLITE_CONFIG_MEMSTATUS
+**
^This option takes single argument of type int, interpreted as a +** boolean, which enables or disables the collection of memory allocation +** statistics. ^(When memory allocation statistics are disabled, the +** following SQLite interfaces become non-operational: +**
    +**
  • [sqlite3_memory_used()] +**
  • [sqlite3_memory_highwater()] +**
  • [sqlite3_soft_heap_limit64()] +**
  • [sqlite3_status()] +**
)^ +** ^Memory allocation statistics are enabled by default unless SQLite is +** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory +** allocation statistics are disabled by default. +**
+** +** [[SQLITE_CONFIG_SCRATCH]]
SQLITE_CONFIG_SCRATCH
+**
^This option specifies a static memory buffer that SQLite can use for +** scratch memory. There are three arguments: A pointer an 8-byte +** aligned memory buffer from which the scratch allocations will be +** drawn, the size of each scratch allocation (sz), +** and the maximum number of scratch allocations (N). The sz +** argument must be a multiple of 16. +** The first argument must be a pointer to an 8-byte aligned buffer +** of at least sz*N bytes of memory. +** ^SQLite will use no more than two scratch buffers per thread. So +** N should be set to twice the expected maximum number of threads. +** ^SQLite will never require a scratch buffer that is more than 6 +** times the database page size. ^If SQLite needs needs additional +** scratch memory beyond what is provided by this configuration option, then +** [sqlite3_malloc()] will be used to obtain the memory needed.
+** +** [[SQLITE_CONFIG_PAGECACHE]]
SQLITE_CONFIG_PAGECACHE
+**
^This option specifies a static memory buffer that SQLite can use for +** the database page cache with the default page cache implementation. +** This configuration should not be used if an application-define page +** cache implementation is loaded using the SQLITE_CONFIG_PCACHE2 option. +** There are three arguments to this option: A pointer to 8-byte aligned +** memory, the size of each page buffer (sz), and the number of pages (N). +** The sz argument should be the size of the largest database page +** (a power of two between 512 and 32768) plus a little extra for each +** page header. ^The page header size is 20 to 40 bytes depending on +** the host architecture. ^It is harmless, apart from the wasted memory, +** to make sz a little too large. The first +** argument should point to an allocation of at least sz*N bytes of memory. +** ^SQLite will use the memory provided by the first argument to satisfy its +** memory needs for the first N pages that it adds to cache. ^If additional +** page cache memory is needed beyond what is provided by this option, then +** SQLite goes to [sqlite3_malloc()] for the additional storage space. +** The pointer in the first argument must +** be aligned to an 8-byte boundary or subsequent behavior of SQLite +** will be undefined.
+** +** [[SQLITE_CONFIG_HEAP]]
SQLITE_CONFIG_HEAP
+**
^This option specifies a static memory buffer that SQLite will use +** for all of its dynamic memory allocation needs beyond those provided +** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE]. +** There are three arguments: An 8-byte aligned pointer to the memory, +** the number of bytes in the memory buffer, and the minimum allocation size. +** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts +** to using its default memory allocator (the system malloc() implementation), +** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the +** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or +** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory +** allocator is engaged to handle all of SQLites memory allocation needs. +** The first pointer (the memory pointer) must be aligned to an 8-byte +** boundary or subsequent behavior of SQLite will be undefined. +** The minimum allocation size is capped at 2**12. Reasonable values +** for the minimum allocation size are 2**5 through 2**8.
+** +** [[SQLITE_CONFIG_MUTEX]]
SQLITE_CONFIG_MUTEX
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mutex_methods] structure. The argument specifies +** alternative low-level mutex routines to be used in place +** the mutex routines built into SQLite.)^ ^SQLite makes a copy of the +** content of the [sqlite3_mutex_methods] structure before the call to +** [sqlite3_config()] returns. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_GETMUTEX]]
SQLITE_CONFIG_GETMUTEX
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mutex_methods] structure. The +** [sqlite3_mutex_methods] +** structure is filled with the currently defined mutex routines.)^ +** This option can be used to overload the default mutex allocation +** routines with a wrapper used to track mutex usage for performance +** profiling or testing, for example. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_LOOKASIDE]]
SQLITE_CONFIG_LOOKASIDE
+**
^(This option takes two arguments that determine the default +** memory allocation for the lookaside memory allocator on each +** [database connection]. The first argument is the +** size of each lookaside buffer slot and the second is the number of +** slots allocated to each database connection.)^ ^(This option sets the +** default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] +** verb to [sqlite3_db_config()] can be used to change the lookaside +** configuration on individual connections.)^
+** +** [[SQLITE_CONFIG_PCACHE2]]
SQLITE_CONFIG_PCACHE2
+**
^(This option takes a single argument which is a pointer to +** an [sqlite3_pcache_methods2] object. This object specifies the interface +** to a custom page cache implementation.)^ ^SQLite makes a copy of the +** object and uses it for page cache memory allocations.
+** +** [[SQLITE_CONFIG_GETPCACHE2]]
SQLITE_CONFIG_GETPCACHE2
+**
^(This option takes a single argument which is a pointer to an +** [sqlite3_pcache_methods2] object. SQLite copies of the current +** page cache implementation into that object.)^
+** +** [[SQLITE_CONFIG_LOG]]
SQLITE_CONFIG_LOG
+**
^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a +** function with a call signature of void(*)(void*,int,const char*), +** and a pointer to void. ^If the function pointer is not NULL, it is +** invoked by [sqlite3_log()] to process each logging event. ^If the +** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op. +** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is +** passed through as the first parameter to the application-defined logger +** function whenever that function is invoked. ^The second parameter to +** the logger function is a copy of the first parameter to the corresponding +** [sqlite3_log()] call and is intended to be a [result code] or an +** [extended result code]. ^The third parameter passed to the logger is +** log message after formatting via [sqlite3_snprintf()]. +** The SQLite logging interface is not reentrant; the logger function +** supplied by the application must not invoke any SQLite interface. +** In a multi-threaded application, the application-defined logger +** function must be threadsafe.
+** +** [[SQLITE_CONFIG_URI]]
SQLITE_CONFIG_URI +**
This option takes a single argument of type int. If non-zero, then +** URI handling is globally enabled. If the parameter is zero, then URI handling +** is globally disabled. If URI handling is globally enabled, all filenames +** passed to [sqlite3_open()], [sqlite3_open_v2()], [sqlite3_open16()] or +** specified as part of [ATTACH] commands are interpreted as URIs, regardless +** of whether or not the [SQLITE_OPEN_URI] flag is set when the database +** connection is opened. If it is globally disabled, filenames are +** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the +** database connection is opened. By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** [SQLITE_USE_URI] symbol defined. +** +** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]]
SQLITE_CONFIG_COVERING_INDEX_SCAN +**
This option takes a single integer argument which is interpreted as +** a boolean in order to enable or disable the use of covering indices for +** full table scans in the query optimizer. The default setting is determined +** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on" +** if that compile-time option is omitted. +** The ability to disable the use of covering indices for full table scans +** is because some incorrectly coded legacy applications might malfunction +** malfunction when the optimization is enabled. Providing the ability to +** disable the optimization allows the older, buggy application code to work +** without change even with newer versions of SQLite. +** +** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]] +**
SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE +**
These options are obsolete and should not be used by new code. +** They are retained for backwards compatibility but are now no-ops. +**
+** +** [[SQLITE_CONFIG_SQLLOG]] +**
SQLITE_CONFIG_SQLLOG +**
This option is only available if sqlite is compiled with the +** SQLITE_ENABLE_SQLLOG pre-processor macro defined. The first argument should +** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). +** The second should be of type (void*). The callback is invoked by the library +** in three separate circumstances, identified by the value passed as the +** fourth parameter. If the fourth parameter is 0, then the database connection +** passed as the second argument has just been opened. The third argument +** points to a buffer containing the name of the main database file. If the +** fourth parameter is 1, then the SQL statement that the third parameter +** points to has just been executed. Or, if the fourth parameter is 2, then +** the connection being passed as the second parameter is being closed. The +** third parameter is passed NULL In this case. +** +*/ +#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ +#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ +#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ +#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */ +#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ +#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ +#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ +#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ +#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ +/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ +#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ +#define SQLITE_CONFIG_PCACHE 14 /* no-op */ +#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */ +#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ +#define SQLITE_CONFIG_URI 17 /* int */ +#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */ +#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */ + +/* +** CAPI3REF: Database Connection Configuration Options +** +** These constants are the available integer configuration options that +** can be passed as the second argument to the [sqlite3_db_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_db_config()] to make sure that +** the call worked. ^The [sqlite3_db_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+**
SQLITE_DBCONFIG_LOOKASIDE
+**
^This option takes three additional arguments that determine the +** [lookaside memory allocator] configuration for the [database connection]. +** ^The first argument (the third parameter to [sqlite3_db_config()] is a +** pointer to a memory buffer to use for lookaside memory. +** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb +** may be NULL in which case SQLite will allocate the +** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the +** size of each lookaside buffer slot. ^The third argument is the number of +** slots. The size of the buffer in the first argument must be greater than +** or equal to the product of the second and third arguments. The buffer +** must be aligned to an 8-byte boundary. ^If the second argument to +** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally +** rounded down to the next smaller multiple of 8. ^(The lookaside memory +** configuration for a database connection can only be changed when that +** connection is not currently using lookaside memory, or in other words +** when the "current value" returned by +** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero. +** Any attempt to change the lookaside memory configuration when lookaside +** memory is in use leaves the configuration unchanged and returns +** [SQLITE_BUSY].)^
+** +**
SQLITE_DBCONFIG_ENABLE_FKEY
+**
^This option is used to enable or disable the enforcement of +** [foreign key constraints]. There should be two additional arguments. +** The first argument is an integer which is 0 to disable FK enforcement, +** positive to enable FK enforcement or negative to leave FK enforcement +** unchanged. The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether FK enforcement is off or on +** following this call. The second parameter may be a NULL pointer, in +** which case the FK enforcement setting is not reported back.
+** +**
SQLITE_DBCONFIG_ENABLE_TRIGGER
+**
^This option is used to enable or disable [CREATE TRIGGER | triggers]. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable triggers, +** positive to enable triggers or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether triggers are disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the trigger setting is not reported back.
+** +**
+*/ +#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ +#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */ + + +/* +** CAPI3REF: Enable Or Disable Extended Result Codes +** +** ^The sqlite3_extended_result_codes() routine enables or disables the +** [extended result codes] feature of SQLite. ^The extended result +** codes are disabled by default for historical compatibility. +*/ +SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** CAPI3REF: Last Insert Rowid +** +** ^Each entry in an SQLite table has a unique 64-bit signed +** integer key called the [ROWID | "rowid"]. ^The rowid is always available +** as an undeclared column named ROWID, OID, or _ROWID_ as long as those +** names are not also used by explicitly declared columns. ^If +** the table has a column of type [INTEGER PRIMARY KEY] then that column +** is another alias for the rowid. +** +** ^This routine returns the [rowid] of the most recent +** successful [INSERT] into the database from the [database connection] +** in the first argument. ^As of SQLite version 3.7.7, this routines +** records the last insert rowid of both ordinary tables and [virtual tables]. +** ^If no successful [INSERT]s +** have ever occurred on that database connection, zero is returned. +** +** ^(If an [INSERT] occurs within a trigger or within a [virtual table] +** method, then this routine will return the [rowid] of the inserted +** row as long as the trigger or virtual table method is running. +** But once the trigger or virtual table method ends, the value returned +** by this routine reverts to what it was before the trigger or virtual +** table method began.)^ +** +** ^An [INSERT] that fails due to a constraint violation is not a +** successful [INSERT] and does not change the value returned by this +** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, +** and INSERT OR ABORT make no changes to the return value of this +** routine when their insertion fails. ^(When INSERT OR REPLACE +** encounters a constraint violation, it does not fail. The +** INSERT continues to completion after deleting rows that caused +** the constraint problem so INSERT OR REPLACE will always change +** the return value of this interface.)^ +** +** ^For the purposes of this routine, an [INSERT] is considered to +** be successful even if it is subsequently rolled back. +** +** This function is accessible to SQL statements via the +** [last_insert_rowid() SQL function]. +** +** If a separate thread performs a new [INSERT] on the same +** database connection while the [sqlite3_last_insert_rowid()] +** function is running and thus changes the last insert [rowid], +** then the value returned by [sqlite3_last_insert_rowid()] is +** unpredictable and might not equal either the old or the new +** last insert [rowid]. +*/ +SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** CAPI3REF: Count The Number Of Rows Modified +** +** ^This function returns the number of database rows that were changed +** or inserted or deleted by the most recently completed SQL statement +** on the [database connection] specified by the first parameter. +** ^(Only changes that are directly specified by the [INSERT], [UPDATE], +** or [DELETE] statement are counted. Auxiliary changes caused by +** triggers or [foreign key actions] are not counted.)^ Use the +** [sqlite3_total_changes()] function to find the total number of changes +** including changes caused by triggers and foreign key actions. +** +** ^Changes to a view that are simulated by an [INSTEAD OF trigger] +** are not counted. Only real table changes are counted. +** +** ^(A "row change" is a change to a single row of a single table +** caused by an INSERT, DELETE, or UPDATE statement. Rows that +** are changed as side effects of [REPLACE] constraint resolution, +** rollback, ABORT processing, [DROP TABLE], or by any other +** mechanisms do not count as direct row changes.)^ +** +** A "trigger context" is a scope of execution that begins and +** ends with the script of a [CREATE TRIGGER | trigger]. +** Most SQL statements are +** evaluated outside of any trigger. This is the "top level" +** trigger context. If a trigger fires from the top level, a +** new trigger context is entered for the duration of that one +** trigger. Subtriggers create subcontexts for their duration. +** +** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does +** not create a new trigger context. +** +** ^This function returns the number of direct row changes in the +** most recent INSERT, UPDATE, or DELETE statement within the same +** trigger context. +** +** ^Thus, when called from the top level, this function returns the +** number of changes in the most recent INSERT, UPDATE, or DELETE +** that also occurred at the top level. ^(Within the body of a trigger, +** the sqlite3_changes() interface can be called to find the number of +** changes in the most recently completed INSERT, UPDATE, or DELETE +** statement within the body of the same trigger. +** However, the number returned does not include changes +** caused by subtriggers since those have their own context.)^ +** +** See also the [sqlite3_total_changes()] interface, the +** [count_changes pragma], and the [changes() SQL function]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_changes()] is running then the value returned +** is unpredictable and not meaningful. +*/ +SQLITE_API int sqlite3_changes(sqlite3*); + +/* +** CAPI3REF: Total Number Of Rows Modified +** +** ^This function returns the number of row changes caused by [INSERT], +** [UPDATE] or [DELETE] statements since the [database connection] was opened. +** ^(The count returned by sqlite3_total_changes() includes all changes +** from all [CREATE TRIGGER | trigger] contexts and changes made by +** [foreign key actions]. However, +** the count does not include changes used to implement [REPLACE] constraints, +** do rollbacks or ABORT processing, or [DROP TABLE] processing. The +** count does not include rows of views that fire an [INSTEAD OF trigger], +** though if the INSTEAD OF trigger makes changes of its own, those changes +** are counted.)^ +** ^The sqlite3_total_changes() function counts the changes as soon as +** the statement that makes them is completed (when the statement handle +** is passed to [sqlite3_reset()] or [sqlite3_finalize()]). +** +** See also the [sqlite3_changes()] interface, the +** [count_changes pragma], and the [total_changes() SQL function]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_total_changes()] is running then the value +** returned is unpredictable and not meaningful. +*/ +SQLITE_API int sqlite3_total_changes(sqlite3*); + +/* +** CAPI3REF: Interrupt A Long-Running Query +** +** ^This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +** +** ^It is safe to call this routine from a thread different from the +** thread that is currently running the database operation. But it +** is not safe to call this routine with a [database connection] that +** is closed or might close before sqlite3_interrupt() returns. +** +** ^If an SQL operation is very nearly finished at the time when +** sqlite3_interrupt() is called, then it might not have an opportunity +** to be interrupted and might continue to completion. +** +** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. +** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE +** that is inside an explicit transaction, then the entire transaction +** will be rolled back automatically. +** +** ^The sqlite3_interrupt(D) call is in effect until all currently running +** SQL statements on [database connection] D complete. ^Any new SQL statements +** that are started after the sqlite3_interrupt() call and before the +** running statements reaches zero are interrupted as if they had been +** running prior to the sqlite3_interrupt() call. ^New SQL statements +** that are started after the running statement count reaches zero are +** not effected by the sqlite3_interrupt(). +** ^A call to sqlite3_interrupt(D) that occurs when there are no running +** SQL statements is a no-op and has no effect on SQL statements +** that are started after the sqlite3_interrupt() call returns. +** +** If the database connection closes while [sqlite3_interrupt()] +** is running then bad things will likely happen. +*/ +SQLITE_API void sqlite3_interrupt(sqlite3*); + +/* +** CAPI3REF: Determine If An SQL Statement Is Complete +** +** These routines are useful during command-line input to determine if the +** currently entered text seems to form a complete SQL statement or +** if additional input is needed before sending the text into +** SQLite for parsing. ^These routines return 1 if the input string +** appears to be a complete SQL statement. ^A statement is judged to be +** complete if it ends with a semicolon token and is not a prefix of a +** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within +** string literals or quoted identifier names or comments are not +** independent tokens (they are part of the token in which they are +** embedded) and thus do not count as a statement terminator. ^Whitespace +** and comments that follow the final semicolon are ignored. +** +** ^These routines return 0 if the statement is incomplete. ^If a +** memory allocation fails, then SQLITE_NOMEM is returned. +** +** ^These routines do not parse the SQL statements thus +** will not detect syntactically incorrect SQL. +** +** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior +** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked +** automatically by sqlite3_complete16(). If that initialization fails, +** then the return value from sqlite3_complete16() will be non-zero +** regardless of whether or not the input SQL is complete.)^ +** +** The input to [sqlite3_complete()] must be a zero-terminated +** UTF-8 string. +** +** The input to [sqlite3_complete16()] must be a zero-terminated +** UTF-16 string in native byte order. +*/ +SQLITE_API int sqlite3_complete(const char *sql); +SQLITE_API int sqlite3_complete16(const void *sql); + +/* +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors +** +** ^This routine sets a callback function that might be invoked whenever +** an attempt is made to open a database table that another thread +** or process has locked. +** +** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] +** is returned immediately upon encountering the lock. ^If the busy callback +** is not NULL, then the callback might be invoked with two arguments. +** +** ^The first argument to the busy handler is a copy of the void* pointer which +** is the third argument to sqlite3_busy_handler(). ^The second argument to +** the busy handler callback is the number of times that the busy handler has +** been invoked for this locking event. ^If the +** busy callback returns 0, then no additional attempts are made to +** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. +** ^If the callback returns non-zero, then another attempt +** is made to open the database for reading and the cycle repeats. +** +** The presence of a busy handler does not guarantee that it will be invoked +** when there is lock contention. ^If SQLite determines that invoking the busy +** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] +** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler. +** Consider a scenario where one process is holding a read lock that +** it is trying to promote to a reserved lock and +** a second process is holding a reserved lock that it is trying +** to promote to an exclusive lock. The first process cannot proceed +** because it is blocked by the second and the second process cannot +** proceed because it is blocked by the first. If both processes +** invoke the busy handlers, neither will make any progress. Therefore, +** SQLite returns [SQLITE_BUSY] for the first process, hoping that this +** will induce the first process to release its read lock and allow +** the second process to proceed. +** +** ^The default busy callback is NULL. +** +** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] +** when SQLite is in the middle of a large transaction where all the +** changes will not fit into the in-memory cache. SQLite will +** already hold a RESERVED lock on the database file, but it needs +** to promote this lock to EXCLUSIVE so that it can spill cache +** pages into the database file without harm to concurrent +** readers. ^If it is unable to promote the lock, then the in-memory +** cache will be left in an inconsistent state and so the error +** code is promoted from the relatively benign [SQLITE_BUSY] to +** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion +** forces an automatic rollback of the changes. See the +** +** CorruptionFollowingBusyError wiki page for a discussion of why +** this is important. +** +** ^(There can only be a single busy handler defined for each +** [database connection]. Setting a new busy handler clears any +** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] +** will also set or clear the busy handler. +** +** The busy callback should not take any actions which modify the +** database connection that invoked the busy handler. Any such actions +** result in undefined behavior. +** +** A busy handler must not close the database connection +** or [prepared statement] that invoked the busy handler. +*/ +SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); + +/* +** CAPI3REF: Set A Busy Timeout +** +** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps +** for a specified amount of time when a table is locked. ^The handler +** will sleep multiple times until at least "ms" milliseconds of sleeping +** have accumulated. ^After at least "ms" milliseconds of sleeping, +** the handler returns 0 which causes [sqlite3_step()] to return +** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. +** +** ^Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +** +** ^(There can only be a single busy handler for a particular +** [database connection] any any given moment. If another busy handler +** was defined (using [sqlite3_busy_handler()]) prior to calling +** this routine, that other busy handler is cleared.)^ +*/ +SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** CAPI3REF: Convenience Routines For Running Queries +** +** This is a legacy interface that is preserved for backwards compatibility. +** Use of this interface is not recommended. +** +** Definition: A result table is memory data structure created by the +** [sqlite3_get_table()] interface. A result table records the +** complete query results from one or more queries. +** +** The table conceptually has a number of rows and columns. But +** these numbers are not part of the result table itself. These +** numbers are obtained separately. Let N be the number of rows +** and M be the number of columns. +** +** A result table is an array of pointers to zero-terminated UTF-8 strings. +** There are (N+1)*M elements in the array. The first M pointers point +** to zero-terminated strings that contain the names of the columns. +** The remaining entries all point to query results. NULL values result +** in NULL pointers. All other values are in their UTF-8 zero-terminated +** string representation as returned by [sqlite3_column_text()]. +** +** A result table might consist of one or more memory allocations. +** It is not safe to pass a result table directly to [sqlite3_free()]. +** A result table should be deallocated using [sqlite3_free_table()]. +** +** ^(As an example of the result table format, suppose a query result +** is as follows: +** +** 
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+**
+** +** There are two column (M==2) and three rows (N==3). Thus the +** result table has 8 entries. Suppose the result table is stored +** in an array names azResult. Then azResult holds this content: +** +** 
+**        azResult[0] = "Name";
+**        azResult[1] = "Age";
+**        azResult[2] = "Alice";
+**        azResult[3] = "43";
+**        azResult[4] = "Bob";
+**        azResult[5] = "28";
+**        azResult[6] = "Cindy";
+**        azResult[7] = "21";
+**
)^ +** +** ^The sqlite3_get_table() function evaluates one or more +** semicolon-separated SQL statements in the zero-terminated UTF-8 +** string of its 2nd parameter and returns a result table to the +** pointer given in its 3rd parameter. +** +** After the application has finished with the result from sqlite3_get_table(), +** it must pass the result table pointer to sqlite3_free_table() in order to +** release the memory that was malloced. Because of the way the +** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling +** function must not try to call [sqlite3_free()] directly. Only +** [sqlite3_free_table()] is able to release the memory properly and safely. +** +** The sqlite3_get_table() interface is implemented as a wrapper around +** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access +** to any internal data structures of SQLite. It uses only the public +** interface defined here. As a consequence, errors that occur in the +** wrapper layer outside of the internal [sqlite3_exec()] call are not +** reflected in subsequent calls to [sqlite3_errcode()] or +** [sqlite3_errmsg()]. +*/ +SQLITE_API int sqlite3_get_table( + sqlite3 *db, /* An open database */ + const char *zSql, /* SQL to be evaluated */ + char ***pazResult, /* Results of the query */ + int *pnRow, /* Number of result rows written here */ + int *pnColumn, /* Number of result columns written here */ + char **pzErrmsg /* Error msg written here */ +); +SQLITE_API void sqlite3_free_table(char **result); + +/* +** CAPI3REF: Formatted String Printing Functions +** +** These routines are work-alikes of the "printf()" family of functions +** from the standard C library. +** +** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their +** results into memory obtained from [sqlite3_malloc()]. +** The strings returned by these two routines should be +** released by [sqlite3_free()]. ^Both routines return a +** NULL pointer if [sqlite3_malloc()] is unable to allocate enough +** memory to hold the resulting string. +** +** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from +** the standard C library. The result is written into the +** buffer supplied as the second parameter whose size is given by +** the first parameter. Note that the order of the +** first two parameters is reversed from snprintf().)^ This is an +** historical accident that cannot be fixed without breaking +** backwards compatibility. ^(Note also that sqlite3_snprintf() +** returns a pointer to its buffer instead of the number of +** characters actually written into the buffer.)^ We admit that +** the number of characters written would be a more useful return +** value but we cannot change the implementation of sqlite3_snprintf() +** now without breaking compatibility. +** +** ^As long as the buffer size is greater than zero, sqlite3_snprintf() +** guarantees that the buffer is always zero-terminated. ^The first +** parameter "n" is the total size of the buffer, including space for +** the zero terminator. So the longest string that can be completely +** written will be n-1 characters. +** +** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf(). +** +** These routines all implement some additional formatting +** options that are useful for constructing SQL statements. +** All of the usual printf() formatting options apply. In addition, there +** is are "%q", "%Q", and "%z" options. +** +** ^(The %q option works like %s in that it substitutes a nul-terminated +** string from the argument list. But %q also doubles every '\'' character. +** %q is designed for use inside a string literal.)^ By doubling each '\'' +** character it escapes that character and allows it to be inserted into +** the string. +** +** For example, assume the string variable zText contains text as follows: +** +** 
+**  char *zText = "It's a happy day!";
+**
+** +** One can use this text in an SQL statement as follows: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** Because the %q format string is used, the '\'' character in zText +** is escaped and the SQL generated is as follows: +** +** 
+**  INSERT INTO table1 VALUES('It''s a happy day!')
+**
+** +** This is correct. Had we used %s instead of %q, the generated SQL +** would have looked like this: +** +** 
+**  INSERT INTO table1 VALUES('It's a happy day!');
+**
+** +** This second example is an SQL syntax error. As a general rule you should +** always use %q instead of %s when inserting text into a string literal. +** +** ^(The %Q option works like %q except it also adds single quotes around +** the outside of the total string. Additionally, if the parameter in the +** argument list is a NULL pointer, %Q substitutes the text "NULL" (without +** single quotes).)^ So, for example, one could say: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** The code above will render a correct SQL statement in the zSQL +** variable even if the zText variable is a NULL pointer. +** +** ^(The "%z" formatting option works like "%s" but with the +** addition that after the string has been read and copied into +** the result, [sqlite3_free()] is called on the input string.)^ +*/ +SQLITE_API char *sqlite3_mprintf(const char*,...); +SQLITE_API char *sqlite3_vmprintf(const char*, va_list); +SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...); +SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list); + +/* +** CAPI3REF: Memory Allocation Subsystem +** +** The SQLite core uses these three routines for all of its own +** internal memory allocation needs. "Core" in the previous sentence +** does not include operating-system specific VFS implementation. The +** Windows VFS uses native malloc() and free() for some operations. +** +** ^The sqlite3_malloc() routine returns a pointer to a block +** of memory at least N bytes in length, where N is the parameter. +** ^If sqlite3_malloc() is unable to obtain sufficient free +** memory, it returns a NULL pointer. ^If the parameter N to +** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns +** a NULL pointer. +** +** ^Calling sqlite3_free() with a pointer previously returned +** by sqlite3_malloc() or sqlite3_realloc() releases that memory so +** that it might be reused. ^The sqlite3_free() routine is +** a no-op if is called with a NULL pointer. Passing a NULL pointer +** to sqlite3_free() is harmless. After being freed, memory +** should neither be read nor written. Even reading previously freed +** memory might result in a segmentation fault or other severe error. +** Memory corruption, a segmentation fault, or other severe error +** might result if sqlite3_free() is called with a non-NULL pointer that +** was not obtained from sqlite3_malloc() or sqlite3_realloc(). +** +** ^(The sqlite3_realloc() interface attempts to resize a +** prior memory allocation to be at least N bytes, where N is the +** second parameter. The memory allocation to be resized is the first +** parameter.)^ ^ If the first parameter to sqlite3_realloc() +** is a NULL pointer then its behavior is identical to calling +** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). +** ^If the second parameter to sqlite3_realloc() is zero or +** negative then the behavior is exactly the same as calling +** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). +** ^sqlite3_realloc() returns a pointer to a memory allocation +** of at least N bytes in size or NULL if sufficient memory is unavailable. +** ^If M is the size of the prior allocation, then min(N,M) bytes +** of the prior allocation are copied into the beginning of buffer returned +** by sqlite3_realloc() and the prior allocation is freed. +** ^If sqlite3_realloc() returns NULL, then the prior allocation +** is not freed. +** +** ^The memory returned by sqlite3_malloc() and sqlite3_realloc() +** is always aligned to at least an 8 byte boundary, or to a +** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time +** option is used. +** +** In SQLite version 3.5.0 and 3.5.1, it was possible to define +** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in +** implementation of these routines to be omitted. That capability +** is no longer provided. Only built-in memory allocators can be used. +** +** Prior to SQLite version 3.7.10, the Windows OS interface layer called +** the system malloc() and free() directly when converting +** filenames between the UTF-8 encoding used by SQLite +** and whatever filename encoding is used by the particular Windows +** installation. Memory allocation errors were detected, but +** they were reported back as [SQLITE_CANTOPEN] or +** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. +** +** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] +** must be either NULL or else pointers obtained from a prior +** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have +** not yet been released. +** +** The application must not read or write any part of +** a block of memory after it has been released using +** [sqlite3_free()] or [sqlite3_realloc()]. +*/ +SQLITE_API void *sqlite3_malloc(int); +SQLITE_API void *sqlite3_realloc(void*, int); +SQLITE_API void sqlite3_free(void*); + +/* +** CAPI3REF: Memory Allocator Statistics +** +** SQLite provides these two interfaces for reporting on the status +** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] +** routines, which form the built-in memory allocation subsystem. +** +** ^The [sqlite3_memory_used()] routine returns the number of bytes +** of memory currently outstanding (malloced but not freed). +** ^The [sqlite3_memory_highwater()] routine returns the maximum +** value of [sqlite3_memory_used()] since the high-water mark +** was last reset. ^The values returned by [sqlite3_memory_used()] and +** [sqlite3_memory_highwater()] include any overhead +** added by SQLite in its implementation of [sqlite3_malloc()], +** but not overhead added by the any underlying system library +** routines that [sqlite3_malloc()] may call. +** +** ^The memory high-water mark is reset to the current value of +** [sqlite3_memory_used()] if and only if the parameter to +** [sqlite3_memory_highwater()] is true. ^The value returned +** by [sqlite3_memory_highwater(1)] is the high-water mark +** prior to the reset. +*/ +SQLITE_API sqlite3_int64 sqlite3_memory_used(void); +SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag); + +/* +** CAPI3REF: Pseudo-Random Number Generator +** +** SQLite contains a high-quality pseudo-random number generator (PRNG) used to +** select random [ROWID | ROWIDs] when inserting new records into a table that +** already uses the largest possible [ROWID]. The PRNG is also used for +** the build-in random() and randomblob() SQL functions. This interface allows +** applications to access the same PRNG for other purposes. +** +** ^A call to this routine stores N bytes of randomness into buffer P. +** +** ^The first time this routine is invoked (either internally or by +** the application) the PRNG is seeded using randomness obtained +** from the xRandomness method of the default [sqlite3_vfs] object. +** ^On all subsequent invocations, the pseudo-randomness is generated +** internally and without recourse to the [sqlite3_vfs] xRandomness +** method. +*/ +SQLITE_API void sqlite3_randomness(int N, void *P); + +/* +** CAPI3REF: Compile-Time Authorization Callbacks +** +** ^This routine registers an authorizer callback with a particular +** [database connection], supplied in the first argument. +** ^The authorizer callback is invoked as SQL statements are being compiled +** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], +** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various +** points during the compilation process, as logic is being created +** to perform various actions, the authorizer callback is invoked to +** see if those actions are allowed. ^The authorizer callback should +** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the +** specific action but allow the SQL statement to continue to be +** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be +** rejected with an error. ^If the authorizer callback returns +** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] +** then the [sqlite3_prepare_v2()] or equivalent call that triggered +** the authorizer will fail with an error message. +** +** When the callback returns [SQLITE_OK], that means the operation +** requested is ok. ^When the callback returns [SQLITE_DENY], the +** [sqlite3_prepare_v2()] or equivalent call that triggered the +** authorizer will fail with an error message explaining that +** access is denied. +** +** ^The first parameter to the authorizer callback is a copy of the third +** parameter to the sqlite3_set_authorizer() interface. ^The second parameter +** to the callback is an integer [SQLITE_COPY | action code] that specifies +** the particular action to be authorized. ^The third through sixth parameters +** to the callback are zero-terminated strings that contain additional +** details about the action to be authorized. +** +** ^If the action code is [SQLITE_READ] +** and the callback returns [SQLITE_IGNORE] then the +** [prepared statement] statement is constructed to substitute +** a NULL value in place of the table column that would have +** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] +** return can be used to deny an untrusted user access to individual +** columns of a table. +** ^If the action code is [SQLITE_DELETE] and the callback returns +** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the +** [truncate optimization] is disabled and all rows are deleted individually. +** +** An authorizer is used when [sqlite3_prepare | preparing] +** SQL statements from an untrusted source, to ensure that the SQL statements +** do not try to access data they are not allowed to see, or that they do not +** try to execute malicious statements that damage the database. For +** example, an application may allow a user to enter arbitrary +** SQL queries for evaluation by a database. But the application does +** not want the user to be able to make arbitrary changes to the +** database. An authorizer could then be put in place while the +** user-entered SQL is being [sqlite3_prepare | prepared] that +** disallows everything except [SELECT] statements. +** +** Applications that need to process SQL from untrusted sources +** might also consider lowering resource limits using [sqlite3_limit()] +** and limiting database size using the [max_page_count] [PRAGMA] +** in addition to using an authorizer. +** +** ^(Only a single authorizer can be in place on a database connection +** at a time. Each call to sqlite3_set_authorizer overrides the +** previous call.)^ ^Disable the authorizer by installing a NULL callback. +** The authorizer is disabled by default. +** +** The authorizer callback must not do anything that will modify +** the database connection that invoked the authorizer callback. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the +** statement might be re-prepared during [sqlite3_step()] due to a +** schema change. Hence, the application should ensure that the +** correct authorizer callback remains in place during the [sqlite3_step()]. +** +** ^Note that the authorizer callback is invoked only during +** [sqlite3_prepare()] or its variants. Authorization is not +** performed during statement evaluation in [sqlite3_step()], unless +** as stated in the previous paragraph, sqlite3_step() invokes +** sqlite3_prepare_v2() to reprepare a statement after a schema change. +*/ +SQLITE_API int sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); + +/* +** CAPI3REF: Authorizer Return Codes +** +** The [sqlite3_set_authorizer | authorizer callback function] must +** return either [SQLITE_OK] or one of these two constants in order +** to signal SQLite whether or not the action is permitted. See the +** [sqlite3_set_authorizer | authorizer documentation] for additional +** information. +** +** Note that SQLITE_IGNORE is also used as a [SQLITE_ROLLBACK | return code] +** from the [sqlite3_vtab_on_conflict()] interface. +*/ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** CAPI3REF: Authorizer Action Codes +** +** The [sqlite3_set_authorizer()] interface registers a callback function +** that is invoked to authorize certain SQL statement actions. The +** second parameter to the callback is an integer code that specifies +** what action is being authorized. These are the integer action codes that +** the authorizer callback may be passed. +** +** These action code values signify what kind of operation is to be +** authorized. The 3rd and 4th parameters to the authorization +** callback function will be parameters or NULL depending on which of these +** codes is used as the second parameter. ^(The 5th parameter to the +** authorizer callback is the name of the database ("main", "temp", +** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** top-level SQL code. +*/ +/******************************************* 3rd ************ 4th ***********/ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* Operation NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* NULL Function Name */ +#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ +#define SQLITE_COPY 0 /* No longer used */ + +/* +** CAPI3REF: Tracing And Profiling Functions +** +** These routines register callback functions that can be used for +** tracing and profiling the execution of SQL statements. +** +** ^The callback function registered by sqlite3_trace() is invoked at +** various times when an SQL statement is being run by [sqlite3_step()]. +** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the +** SQL statement text as the statement first begins executing. +** ^(Additional sqlite3_trace() callbacks might occur +** as each triggered subprogram is entered. The callbacks for triggers +** contain a UTF-8 SQL comment that identifies the trigger.)^ +** +** ^The callback function registered by sqlite3_profile() is invoked +** as each SQL statement finishes. ^The profile callback contains +** the original statement text and an estimate of wall-clock time +** of how long that statement took to run. ^The profile callback +** time is in units of nanoseconds, however the current implementation +** is only capable of millisecond resolution so the six least significant +** digits in the time are meaningless. Future versions of SQLite +** might provide greater resolution on the profiler callback. The +** sqlite3_profile() function is considered experimental and is +** subject to change in future versions of SQLite. +*/ +SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); +SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite3_uint64), void*); + +/* +** CAPI3REF: Query Progress Callbacks +** +** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback +** function X to be invoked periodically during long running calls to +** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for +** database connection D. An example use for this +** interface is to keep a GUI updated during a large query. +** +** ^The parameter P is passed through as the only parameter to the +** callback function X. ^The parameter N is the number of +** [virtual machine instructions] that are evaluated between successive +** invocations of the callback X. +** +** ^Only a single progress handler may be defined at one time per +** [database connection]; setting a new progress handler cancels the +** old one. ^Setting parameter X to NULL disables the progress handler. +** ^The progress handler is also disabled by setting N to a value less +** than 1. +** +** ^If the progress callback returns non-zero, the operation is +** interrupted. This feature can be used to implement a +** "Cancel" button on a GUI progress dialog box. +** +** The progress handler callback must not do anything that will modify +** the database connection that invoked the progress handler. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +*/ +SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** CAPI3REF: Opening A New Database Connection +** +** ^These routines open an SQLite database file as specified by the +** filename argument. ^The filename argument is interpreted as UTF-8 for +** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte +** order for sqlite3_open16(). ^(A [database connection] handle is usually +** returned in *ppDb, even if an error occurs. The only exception is that +** if SQLite is unable to allocate memory to hold the [sqlite3] object, +** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] +** object.)^ ^(If the database is opened (and/or created) successfully, then +** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The +** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain +** an English language description of the error following a failure of any +** of the sqlite3_open() routines. +** +** ^The default encoding for the database will be UTF-8 if +** sqlite3_open() or sqlite3_open_v2() is called and +** UTF-16 in the native byte order if sqlite3_open16() is used. +** +** Whether or not an error occurs when it is opened, resources +** associated with the [database connection] handle should be released by +** passing it to [sqlite3_close()] when it is no longer required. +** +** The sqlite3_open_v2() interface works like sqlite3_open() +** except that it accepts two additional parameters for additional control +** over the new database connection. ^(The flags parameter to +** sqlite3_open_v2() can take one of +** the following three values, optionally combined with the +** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE], +** [SQLITE_OPEN_PRIVATECACHE], and/or [SQLITE_OPEN_URI] flags:)^ +** +**
+** ^(
[SQLITE_OPEN_READONLY]
+**
The database is opened in read-only mode. If the database does not +** already exist, an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE]
+**
The database is opened for reading and writing if possible, or reading +** only if the file is write protected by the operating system. In either +** case the database must already exist, otherwise an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
+**
The database is opened for reading and writing, and is created if +** it does not already exist. This is the behavior that is always used for +** sqlite3_open() and sqlite3_open16().
)^ +**
+** +** If the 3rd parameter to sqlite3_open_v2() is not one of the +** combinations shown above optionally combined with other +** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] +** then the behavior is undefined. +** +** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection +** opens in the multi-thread [threading mode] as long as the single-thread +** mode has not been set at compile-time or start-time. ^If the +** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens +** in the serialized [threading mode] unless single-thread was +** previously selected at compile-time or start-time. +** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be +** eligible to use [shared cache mode], regardless of whether or not shared +** cache is enabled using [sqlite3_enable_shared_cache()]. ^The +** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not +** participate in [shared cache mode] even if it is enabled. +** +** ^The fourth parameter to sqlite3_open_v2() is the name of the +** [sqlite3_vfs] object that defines the operating system interface that +** the new database connection should use. ^If the fourth parameter is +** a NULL pointer then the default [sqlite3_vfs] object is used. +** +** ^If the filename is ":memory:", then a private, temporary in-memory database +** is created for the connection. ^This in-memory database will vanish when +** the database connection is closed. Future versions of SQLite might +** make use of additional special filenames that begin with the ":" character. +** It is recommended that when a database filename actually does begin with +** a ":" character you should prefix the filename with a pathname such as +** "./" to avoid ambiguity. +** +** ^If the filename is an empty string, then a private, temporary +** on-disk database will be created. ^This private database will be +** automatically deleted as soon as the database connection is closed. +** +** [[URI filenames in sqlite3_open()]]

URI Filenames

+** +** ^If [URI filename] interpretation is enabled, and the filename argument +** begins with "file:", then the filename is interpreted as a URI. ^URI +** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is +** set in the fourth argument to sqlite3_open_v2(), or if it has +** been enabled globally using the [SQLITE_CONFIG_URI] option with the +** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option. +** As of SQLite version 3.7.7, URI filename interpretation is turned off +** by default, but future releases of SQLite might enable URI filename +** interpretation by default. See "[URI filenames]" for additional +** information. +** +** URI filenames are parsed according to RFC 3986. ^If the URI contains an +** authority, then it must be either an empty string or the string +** "localhost". ^If the authority is not an empty string or "localhost", an +** error is returned to the caller. ^The fragment component of a URI, if +** present, is ignored. +** +** ^SQLite uses the path component of the URI as the name of the disk file +** which contains the database. ^If the path begins with a '/' character, +** then it is interpreted as an absolute path. ^If the path does not begin +** with a '/' (meaning that the authority section is omitted from the URI) +** then the path is interpreted as a relative path. +** ^On windows, the first component of an absolute path +** is a drive specification (e.g. "C:"). +** +** [[core URI query parameters]] +** The query component of a URI may contain parameters that are interpreted +** either by SQLite itself, or by a [VFS | custom VFS implementation]. +** SQLite interprets the following three query parameters: +** +**
    +**
  • vfs: ^The "vfs" parameter may be used to specify the name of +** a VFS object that provides the operating system interface that should +** be used to access the database file on disk. ^If this option is set to +** an empty string the default VFS object is used. ^Specifying an unknown +** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is +** present, then the VFS specified by the option takes precedence over +** the value passed as the fourth parameter to sqlite3_open_v2(). +** +**
  • mode: ^(The mode parameter may be set to either "ro", "rw", +** "rwc", or "memory". Attempting to set it to any other value is +** an error)^. +** ^If "ro" is specified, then the database is opened for read-only +** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the +** third argument to sqlite3_open_v2(). ^If the mode option is set to +** "rw", then the database is opened for read-write (but not create) +** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had +** been set. ^Value "rwc" is equivalent to setting both +** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If the mode option is +** set to "memory" then a pure [in-memory database] that never reads +** or writes from disk is used. ^It is an error to specify a value for +** the mode parameter that is less restrictive than that specified by +** the flags passed in the third parameter to sqlite3_open_v2(). +** +**
  • cache: ^The cache parameter may be set to either "shared" or +** "private". ^Setting it to "shared" is equivalent to setting the +** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to +** sqlite3_open_v2(). ^Setting the cache parameter to "private" is +** equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit. +** ^If sqlite3_open_v2() is used and the "cache" parameter is present in +** a URI filename, its value overrides any behavior requested by setting +** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag. +**
+** +** ^Specifying an unknown parameter in the query component of a URI is not an +** error. Future versions of SQLite might understand additional query +** parameters. See "[query parameters with special meaning to SQLite]" for +** additional information. +** +** [[URI filename examples]]

URI filename examples

+** +** +**
URI filenames Results +**
file:data.db +** Open the file "data.db" in the current directory. +**
file:/home/fred/data.db
+** file:///home/fred/data.db
+** file://localhost/home/fred/data.db
+** Open the database file "/home/fred/data.db". +**
file://darkstar/home/fred/data.db +** An error. "darkstar" is not a recognized authority. +**
+** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db +** Windows only: Open the file "data.db" on fred's desktop on drive +** C:. Note that the %20 escaping in this example is not strictly +** necessary - space characters can be used literally +** in URI filenames. +**
file:data.db?mode=ro&cache=private +** Open file "data.db" in the current directory for read-only access. +** Regardless of whether or not shared-cache mode is enabled by +** default, use a private cache. +**
file:/home/fred/data.db?vfs=unix-nolock +** Open file "/home/fred/data.db". Use the special VFS "unix-nolock". +**
file:data.db?mode=readonly +** An error. "readonly" is not a valid option for the "mode" parameter. +**
+** +** ^URI hexadecimal escape sequences (%HH) are supported within the path and +** query components of a URI. A hexadecimal escape sequence consists of a +** percent sign - "%" - followed by exactly two hexadecimal digits +** specifying an octet value. ^Before the path or query components of a +** URI filename are interpreted, they are encoded using UTF-8 and all +** hexadecimal escape sequences replaced by a single byte containing the +** corresponding octet. If this process generates an invalid UTF-8 encoding, +** the results are undefined. +** +** Note to Windows users: The encoding used for the filename argument +** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever +** codepage is currently defined. Filenames containing international +** characters must be converted to UTF-8 prior to passing them into +** sqlite3_open() or sqlite3_open_v2(). +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling sqlite3_open() or sqlite3_open_v2(). Otherwise, various +** features that require the use of temporary files may fail. +** +** See also: [sqlite3_temp_directory] +*/ +SQLITE_API int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +); + +/* +** CAPI3REF: Obtain Values For URI Parameters +** +** These are utility routines, useful to VFS implementations, that check +** to see if a database file was a URI that contained a specific query +** parameter, and if so obtains the value of that query parameter. +** +** If F is the database filename pointer passed into the xOpen() method of +** a VFS implementation when the flags parameter to xOpen() has one or +** more of the [SQLITE_OPEN_URI] or [SQLITE_OPEN_MAIN_DB] bits set and +** P is the name of the query parameter, then +** sqlite3_uri_parameter(F,P) returns the value of the P +** parameter if it exists or a NULL pointer if P does not appear as a +** query parameter on F. If P is a query parameter of F +** has no explicit value, then sqlite3_uri_parameter(F,P) returns +** a pointer to an empty string. +** +** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean +** parameter and returns true (1) or false (0) according to the value +** of P. The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the +** value of query parameter P is one of "yes", "true", or "on" in any +** case or if the value begins with a non-zero number. The +** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of +** query parameter P is one of "no", "false", or "off" in any case or +** if the value begins with a numeric zero. If P is not a query +** parameter on F or if the value of P is does not match any of the +** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0). +** +** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a +** 64-bit signed integer and returns that integer, or D if P does not +** exist. If the value of P is something other than an integer, then +** zero is returned. +** +** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and +** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and +** is not a database file pathname pointer that SQLite passed into the xOpen +** VFS method, then the behavior of this routine is undefined and probably +** undesirable. +*/ +SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam); +SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault); +SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64); + + +/* +** CAPI3REF: Error Codes And Messages +** +** ^The sqlite3_errcode() interface returns the numeric [result code] or +** [extended result code] for the most recent failed sqlite3_* API call +** associated with a [database connection]. If a prior API call failed +** but the most recent API call succeeded, the return value from +** sqlite3_errcode() is undefined. ^The sqlite3_extended_errcode() +** interface is the same except that it always returns the +** [extended result code] even when extended result codes are +** disabled. +** +** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF-8 or UTF-16 respectively. +** ^(Memory to hold the error message string is managed internally. +** The application does not need to worry about freeing the result. +** However, the error string might be overwritten or deallocated by +** subsequent calls to other SQLite interface functions.)^ +** +** ^The sqlite3_errstr() interface returns the English-language text +** that describes the [result code], as UTF-8. +** ^(Memory to hold the error message string is managed internally +** and must not be freed by the application)^. +** +** When the serialized [threading mode] is in use, it might be the +** case that a second error occurs on a separate thread in between +** the time of the first error and the call to these interfaces. +** When that happens, the second error will be reported since these +** interfaces always report the most recent result. To avoid +** this, each thread can obtain exclusive use of the [database connection] D +** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning +** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after +** all calls to the interfaces listed here are completed. +** +** If an interface fails with SQLITE_MISUSE, that means the interface +** was invoked incorrectly by the application. In that case, the +** error code and message may or may not be set. +*/ +SQLITE_API int sqlite3_errcode(sqlite3 *db); +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); +SQLITE_API const char *sqlite3_errmsg(sqlite3*); +SQLITE_API const void *sqlite3_errmsg16(sqlite3*); +SQLITE_API const char *sqlite3_errstr(int); + +/* +** CAPI3REF: SQL Statement Object +** KEYWORDS: {prepared statement} {prepared statements} +** +** An instance of this object represents a single SQL statement. +** This object is variously known as a "prepared statement" or a +** "compiled SQL statement" or simply as a "statement". +** +** The life of a statement object goes something like this: +** +**
    +**
  1. Create the object using [sqlite3_prepare_v2()] or a related +** function. +**
  2. Bind values to [host parameters] using the sqlite3_bind_*() +** interfaces. +**
  3. Run the SQL by calling [sqlite3_step()] one or more times. +**
  4. Reset the statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
  5. Destroy the object using [sqlite3_finalize()]. +**
+** +** Refer to documentation on individual methods above for additional +** information. +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Run-time Limits +** +** ^(This interface allows the size of various constructs to be limited +** on a connection by connection basis. The first parameter is the +** [database connection] whose limit is to be set or queried. The +** second parameter is one of the [limit categories] that define a +** class of constructs to be size limited. The third parameter is the +** new limit for that construct.)^ +** +** ^If the new limit is a negative number, the limit is unchanged. +** ^(For each limit category SQLITE_LIMIT_NAME there is a +** [limits | hard upper bound] +** set at compile-time by a C preprocessor macro called +** [limits | SQLITE_MAX_NAME]. +** (The "_LIMIT_" in the name is changed to "_MAX_".))^ +** ^Attempts to increase a limit above its hard upper bound are +** silently truncated to the hard upper bound. +** +** ^Regardless of whether or not the limit was changed, the +** [sqlite3_limit()] interface returns the prior value of the limit. +** ^Hence, to find the current value of a limit without changing it, +** simply invoke this interface with the third parameter set to -1. +** +** Run-time limits are intended for use in applications that manage +** both their own internal database and also databases that are controlled +** by untrusted external sources. An example application might be a +** web browser that has its own databases for storing history and +** separate databases controlled by JavaScript applications downloaded +** off the Internet. The internal databases can be given the +** large, default limits. Databases managed by external sources can +** be given much smaller limits designed to prevent a denial of service +** attack. Developers might also want to use the [sqlite3_set_authorizer()] +** interface to further control untrusted SQL. The size of the database +** created by an untrusted script can be contained using the +** [max_page_count] [PRAGMA]. +** +** New run-time limit categories may be added in future releases. +*/ +SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal); + +/* +** CAPI3REF: Run-Time Limit Categories +** KEYWORDS: {limit category} {*limit categories} +** +** These constants define various performance limits +** that can be lowered at run-time using [sqlite3_limit()]. +** The synopsis of the meanings of the various limits is shown below. +** Additional information is available at [limits | Limits in SQLite]. +** +**
+** [[SQLITE_LIMIT_LENGTH]] ^(
SQLITE_LIMIT_LENGTH
+**
The maximum size of any string or BLOB or table row, in bytes.
)^ +** +** [[SQLITE_LIMIT_SQL_LENGTH]] ^(
SQLITE_LIMIT_SQL_LENGTH
+**
The maximum length of an SQL statement, in bytes.
)^ +** +** [[SQLITE_LIMIT_COLUMN]] ^(
SQLITE_LIMIT_COLUMN
+**
The maximum number of columns in a table definition or in the +** result set of a [SELECT] or the maximum number of columns in an index +** or in an ORDER BY or GROUP BY clause.
)^ +** +** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(
SQLITE_LIMIT_EXPR_DEPTH
+**
The maximum depth of the parse tree on any expression.
)^ +** +** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(
SQLITE_LIMIT_COMPOUND_SELECT
+**
The maximum number of terms in a compound SELECT statement.
)^ +** +** [[SQLITE_LIMIT_VDBE_OP]] ^(
SQLITE_LIMIT_VDBE_OP
+**
The maximum number of instructions in a virtual machine program +** used to implement an SQL statement. This limit is not currently +** enforced, though that might be added in some future release of +** SQLite.
)^ +** +** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(
SQLITE_LIMIT_FUNCTION_ARG
+**
The maximum number of arguments on a function.
)^ +** +** [[SQLITE_LIMIT_ATTACHED]] ^(
SQLITE_LIMIT_ATTACHED
+**
The maximum number of [ATTACH | attached databases].)^
+** +** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]] +** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
+**
The maximum length of the pattern argument to the [LIKE] or +** [GLOB] operators.
)^ +** +** [[SQLITE_LIMIT_VARIABLE_NUMBER]] +** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
+**
The maximum index number of any [parameter] in an SQL statement.)^ +** +** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(
SQLITE_LIMIT_TRIGGER_DEPTH
+**
The maximum depth of recursion for triggers.
)^ +**
+*/ +#define SQLITE_LIMIT_LENGTH 0 +#define SQLITE_LIMIT_SQL_LENGTH 1 +#define SQLITE_LIMIT_COLUMN 2 +#define SQLITE_LIMIT_EXPR_DEPTH 3 +#define SQLITE_LIMIT_COMPOUND_SELECT 4 +#define SQLITE_LIMIT_VDBE_OP 5 +#define SQLITE_LIMIT_FUNCTION_ARG 6 +#define SQLITE_LIMIT_ATTACHED 7 +#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 +#define SQLITE_LIMIT_VARIABLE_NUMBER 9 +#define SQLITE_LIMIT_TRIGGER_DEPTH 10 + +/* +** CAPI3REF: Compiling An SQL Statement +** KEYWORDS: {SQL statement compiler} +** +** To execute an SQL query, it must first be compiled into a byte-code +** program using one of these routines. +** +** The first argument, "db", is a [database connection] obtained from a +** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or +** [sqlite3_open16()]. The database connection must not have been closed. +** +** The second argument, "zSql", is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() +** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() +** use UTF-16. +** +** ^If the nByte argument is less than zero, then zSql is read up to the +** first zero terminator. ^If nByte is non-negative, then it is the maximum +** number of bytes read from zSql. ^When nByte is non-negative, the +** zSql string ends at either the first '\000' or '\u0000' character or +** the nByte-th byte, whichever comes first. If the caller knows +** that the supplied string is nul-terminated, then there is a small +** performance advantage to be gained by passing an nByte parameter that +** is equal to the number of bytes in the input string including +** the nul-terminator bytes as this saves SQLite from having to +** make a copy of the input string. +** +** ^If pzTail is not NULL then *pzTail is made to point to the first byte +** past the end of the first SQL statement in zSql. These routines only +** compile the first statement in zSql, so *pzTail is left pointing to +** what remains uncompiled. +** +** ^*ppStmt is left pointing to a compiled [prepared statement] that can be +** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set +** to NULL. ^If the input text contains no SQL (if the input is an empty +** string or a comment) then *ppStmt is set to NULL. +** The calling procedure is responsible for deleting the compiled +** SQL statement using [sqlite3_finalize()] after it has finished with it. +** ppStmt may not be NULL. +** +** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; +** otherwise an [error code] is returned. +** +** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are +** recommended for all new programs. The two older interfaces are retained +** for backwards compatibility, but their use is discouraged. +** ^In the "v2" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. This causes the [sqlite3_step()] interface to +** behave differently in three ways: +** +**
    +**
  1. +** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. +**
    2. +** +**
  2. +** ^When an error occurs, [sqlite3_step()] will return one of the detailed +** [error codes] or [extended error codes]. ^The legacy behavior was that +** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code +** and the application would have to make a second call to [sqlite3_reset()] +** in order to find the underlying cause of the problem. With the "v2" prepare +** interfaces, the underlying reason for the error is returned immediately. +**
    3. +** +**
  3. +** ^If the specific value bound to [parameter | host parameter] in the +** WHERE clause might influence the choice of query plan for a statement, +** then the statement will be automatically recompiled, as if there had been +** a schema change, on the first [sqlite3_step()] call following any change +** to the [sqlite3_bind_text | bindings] of that [parameter]. +** ^The specific value of WHERE-clause [parameter] might influence the +** choice of query plan if the parameter is the left-hand side of a [LIKE] +** or [GLOB] operator or if the parameter is compared to an indexed column +** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled. +** the +**
    4. +**
+*/ +SQLITE_API int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPI3REF: Retrieving Statement SQL +** +** ^This interface can be used to retrieve a saved copy of the original +** SQL text used to create a [prepared statement] if that statement was +** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. +*/ +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If An SQL Statement Writes The Database +** +** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if +** and only if the [prepared statement] X makes no direct changes to +** the content of the database file. +** +** Note that [application-defined SQL functions] or +** [virtual tables] might change the database indirectly as a side effect. +** ^(For example, if an application defines a function "eval()" that +** calls [sqlite3_exec()], then the following SQL statement would +** change the database file through side-effects: +** +** 
+**    SELECT eval('DELETE FROM t1') FROM t2;
+**
+** +** But because the [SELECT] statement does not change the database file +** directly, sqlite3_stmt_readonly() would still return true.)^ +** +** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK], +** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true, +** since the statements themselves do not actually modify the database but +** rather they control the timing of when other statements modify the +** database. ^The [ATTACH] and [DETACH] statements also cause +** sqlite3_stmt_readonly() to return true since, while those statements +** change the configuration of a database connection, they do not make +** changes to the content of the database files on disk. +*/ +SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If A Prepared Statement Has Been Reset +** +** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the +** [prepared statement] S has been stepped at least once using +** [sqlite3_step(S)] but has not run to completion and/or has not +** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S) +** interface returns false if S is a NULL pointer. If S is not a +** NULL pointer and is not a pointer to a valid [prepared statement] +** object, then the behavior is undefined and probably undesirable. +** +** This interface can be used in combination [sqlite3_next_stmt()] +** to locate all prepared statements associated with a database +** connection that are in need of being reset. This can be used, +** for example, in diagnostic routines to search for prepared +** statements that are holding a transaction open. +*/ +SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*); + +/* +** CAPI3REF: Dynamically Typed Value Object +** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} +** +** SQLite uses the sqlite3_value object to represent all values +** that can be stored in a database table. SQLite uses dynamic typing +** for the values it stores. ^Values stored in sqlite3_value objects +** can be integers, floating point values, strings, BLOBs, or NULL. +** +** An sqlite3_value object may be either "protected" or "unprotected". +** Some interfaces require a protected sqlite3_value. Other interfaces +** will accept either a protected or an unprotected sqlite3_value. +** Every interface that accepts sqlite3_value arguments specifies +** whether or not it requires a protected sqlite3_value. +** +** The terms "protected" and "unprotected" refer to whether or not +** a mutex is held. An internal mutex is held for a protected +** sqlite3_value object but no mutex is held for an unprotected +** sqlite3_value object. If SQLite is compiled to be single-threaded +** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) +** or if SQLite is run in one of reduced mutex modes +** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] +** then there is no distinction between protected and unprotected +** sqlite3_value objects and they can be used interchangeably. However, +** for maximum code portability it is recommended that applications +** still make the distinction between protected and unprotected +** sqlite3_value objects even when not strictly required. +** +** ^The sqlite3_value objects that are passed as parameters into the +** implementation of [application-defined SQL functions] are protected. +** ^The sqlite3_value object returned by +** [sqlite3_column_value()] is unprotected. +** Unprotected sqlite3_value objects may only be used with +** [sqlite3_result_value()] and [sqlite3_bind_value()]. +** The [sqlite3_value_blob | sqlite3_value_type()] family of +** interfaces require protected sqlite3_value objects. +*/ +typedef struct Mem sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. ^A pointer to an sqlite3_context object +** is always first parameter to [application-defined SQL functions]. +** The application-defined SQL function implementation will pass this +** pointer through into calls to [sqlite3_result_int | sqlite3_result()], +** [sqlite3_aggregate_context()], [sqlite3_user_data()], +** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], +** and/or [sqlite3_set_auxdata()]. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements +** KEYWORDS: {host parameter} {host parameters} {host parameter name} +** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} +** +** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, +** literals may be replaced by a [parameter] that matches one of following +** templates: +** +**
    +**
  • ? +**
  • ?NNN +**
  • :VVV +**
  • @VVV +**
  • $VVV +**
+** +** In the templates above, NNN represents an integer literal, +** and VVV represents an alphanumeric identifier.)^ ^The values of these +** parameters (also called "host parameter names" or "SQL parameters") +** can be set using the sqlite3_bind_*() routines defined here. +** +** ^The first argument to the sqlite3_bind_*() routines is always +** a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. +** +** ^The second argument is the index of the SQL parameter to be set. +** ^The leftmost SQL parameter has an index of 1. ^When the same named +** SQL parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** ^The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_index()] API if desired. ^The index +** for "?NNN" parameters is the value of NNN. +** ^The NNN value must be between 1 and the [sqlite3_limit()] +** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999). +** +** ^The third argument is the value to bind to the parameter. +** +** ^(In those routines that have a fourth argument, its value is the +** number of bytes in the parameter. To be clear: the value is the +** number of bytes in the value, not the number of characters.)^ +** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** is negative, then the length of the string is +** the number of bytes up to the first zero terminator. +** If the fourth parameter to sqlite3_bind_blob() is negative, then +** the behavior is undefined. +** If a non-negative fourth parameter is provided to sqlite3_bind_text() +** or sqlite3_bind_text16() then that parameter must be the byte offset +** where the NUL terminator would occur assuming the string were NUL +** terminated. If any NUL characters occur at byte offsets less than +** the value of the fourth parameter then the resulting string value will +** contain embedded NULs. The result of expressions involving strings +** with embedded NULs is undefined. +** +** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and +** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or +** string after SQLite has finished with it. ^The destructor is called +** to dispose of the BLOB or string even if the call to sqlite3_bind_blob(), +** sqlite3_bind_text(), or sqlite3_bind_text16() fails. +** ^If the fifth argument is +** the special value [SQLITE_STATIC], then SQLite assumes that the +** information is in static, unmanaged space and does not need to be freed. +** ^If the fifth argument has the value [SQLITE_TRANSIENT], then +** SQLite makes its own private copy of the data immediately, before +** the sqlite3_bind_*() routine returns. +** +** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeroes. ^A zeroblob uses a fixed amount of memory +** (just an integer to hold its size) while it is being processed. +** Zeroblobs are intended to serve as placeholders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | incremental BLOB I/O] routines. +** ^A negative value for the zeroblob results in a zero-length BLOB. +** +** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer +** for the [prepared statement] or with a prepared statement for which +** [sqlite3_step()] has been called more recently than [sqlite3_reset()], +** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() +** routine is passed a [prepared statement] that has been finalized, the +** result is undefined and probably harmful. +** +** ^Bindings are not cleared by the [sqlite3_reset()] routine. +** ^Unbound parameters are interpreted as NULL. +** +** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an +** [error code] if anything goes wrong. +** ^[SQLITE_RANGE] is returned if the parameter +** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. +** +** See also: [sqlite3_bind_parameter_count()], +** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double); +SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int); +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int); +SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); +SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); + +/* +** CAPI3REF: Number Of SQL Parameters +** +** ^This routine can be used to find the number of [SQL parameters] +** in a [prepared statement]. SQL parameters are tokens of the +** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as +** placeholders for values that are [sqlite3_bind_blob | bound] +** to the parameters at a later time. +** +** ^(This routine actually returns the index of the largest (rightmost) +** parameter. For all forms except ?NNN, this will correspond to the +** number of unique parameters. If parameters of the ?NNN form are used, +** there may be gaps in the list.)^ +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_name()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter +** +** ^The sqlite3_bind_parameter_name(P,N) interface returns +** the name of the N-th [SQL parameter] in the [prepared statement] P. +** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" +** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" +** respectively. +** In other words, the initial ":" or "$" or "@" or "?" +** is included as part of the name.)^ +** ^Parameters of the form "?" without a following integer have no name +** and are referred to as "nameless" or "anonymous parameters". +** +** ^The first host parameter has an index of 1, not 0. +** +** ^If the value N is out of range or if the N-th parameter is +** nameless, then NULL is returned. ^The returned string is +** always in UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()] or +** [sqlite3_prepare16_v2()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name +** +** ^Return the index of an SQL parameter given its name. ^The +** index value returned is suitable for use as the second +** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero +** is returned if no matching parameter is found. ^The parameter +** name must be given in UTF-8 even if the original statement +** was prepared from UTF-16 text using [sqlite3_prepare16_v2()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement +** +** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset +** the [sqlite3_bind_blob | bindings] on a [prepared statement]. +** ^Use this routine to reset all host parameters to NULL. +*/ +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set +** +** ^Return the number of columns in the result set returned by the +** [prepared statement]. ^This routine returns 0 if pStmt is an SQL +** statement that does not return data (for example an [UPDATE]). +** +** See also: [sqlite3_data_count()] +*/ +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set +** +** ^These routines return the name assigned to a particular column +** in the result set of a [SELECT] statement. ^The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF-8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF-16 string. ^The first parameter is the [prepared statement] +** that implements the [SELECT] statement. ^The second parameter is the +** column number. ^The leftmost column is number 0. +** +** ^The returned string pointer is valid until either the [prepared statement] +** is destroyed by [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the next call to +** sqlite3_column_name() or sqlite3_column_name16() on the same column. +** +** ^If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +** +** ^The name of a result column is the value of the "AS" clause for +** that column, if there is an AS clause. If there is no AS clause +** then the name of the column is unspecified and may change from +** one release of SQLite to the next. +*/ +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N); +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result +** +** ^These routines provide a means to determine the database, table, and +** table column that is the origin of a particular result column in +** [SELECT] statement. +** ^The name of the database or table or column can be returned as +** either a UTF-8 or UTF-16 string. ^The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. +** ^The returned string is valid until the [prepared statement] is destroyed +** using [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the same information is requested +** again in a different encoding. +** +** ^The names returned are the original un-aliased names of the +** database, table, and column. +** +** ^The first argument to these interfaces is a [prepared statement]. +** ^These functions return information about the Nth result column returned by +** the statement, where N is the second function argument. +** ^The left-most column is column 0 for these routines. +** +** ^If the Nth column returned by the statement is an expression or +** subquery and is not a column value, then all of these functions return +** NULL. ^These routine might also return NULL if a memory allocation error +** occurs. ^Otherwise, they return the name of the attached database, table, +** or column that query result column was extracted from. +** +** ^As with all other SQLite APIs, those whose names end with "16" return +** UTF-16 encoded strings and the other functions return UTF-8. +** +** ^These APIs are only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. +** +** If two or more threads call one or more of these routines against the same +** prepared statement and column at the same time then the results are +** undefined. +** +** If two or more threads call one or more +** [sqlite3_column_database_name | column metadata interfaces] +** for the same [prepared statement] and result column +** at the same time then the results are undefined. +*/ +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result +** +** ^(The first parameter is a [prepared statement]. +** If this statement is a [SELECT] statement and the Nth column of the +** returned result set of that [SELECT] is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned.)^ ^If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** ^The returned string is always UTF-8 encoded. +** +** ^(For example, given the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** and the following statement to be compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** this routine would return the string "VARIANT" for the second result +** column (i==1), and a NULL pointer for the first result column (i==0).)^ +** +** ^SQLite uses dynamic run-time typing. ^So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. ^Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement +** +** After a [prepared statement] has been prepared using either +** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function +** must be called one or more times to evaluate the statement. +** +** The details of the behavior of the sqlite3_step() interface depend +** on whether the statement was prepared using the newer "v2" interface +** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy +** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "v2" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** ^In the legacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** ^With the "v2" interface, any of the other [result codes] or +** [extended result codes] might be returned as well. +** +** ^[SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. ^If the statement is a [COMMIT] +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a [COMMIT] and occurs within an +** explicit transaction then you should rollback the transaction before +** continuing. +** +** ^[SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] +** is returned each time a new row of data is ready for processing by the +** caller. The values may be accessed using the [column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** ^[SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** ^With the legacy interface, a more specific error code (for example, +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [prepared statement]. ^In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** For all versions of SQLite up to and including 3.6.23.1, a call to +** [sqlite3_reset()] was required after sqlite3_step() returned anything +** other than [SQLITE_ROW] before any subsequent invocation of +** sqlite3_step(). Failure to reset the prepared statement using +** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from +** sqlite3_step(). But after version 3.6.23.1, sqlite3_step() began +** calling [sqlite3_reset()] automatically in this circumstance rather +** than returning [SQLITE_MISUSE]. This is not considered a compatibility +** break because any application that ever receives an SQLITE_MISUSE error +** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option +** can be used to restore the legacy behavior. +** +** Goofy Interface Alert: In the legacy interface, the sqlite3_step() +** API always returns a generic error code, [SQLITE_ERROR], following any +** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call +** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the +** specific [error codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, +** then the more specific [error codes] are returned directly +** by sqlite3_step(). The use of the "v2" interface is recommended. +*/ +SQLITE_API int sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set +** +** ^The sqlite3_data_count(P) interface returns the number of columns in the +** current row of the result set of [prepared statement] P. +** ^If prepared statement P does not have results ready to return +** (via calls to the [sqlite3_column_int | sqlite3_column_*()] of +** interfaces) then sqlite3_data_count(P) returns 0. +** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer. +** ^The sqlite3_data_count(P) routine returns 0 if the previous call to +** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P) +** will return non-zero if previous call to [sqlite3_step](P) returned +** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum] +** where it always returns zero since each step of that multi-step +** pragma returns 0 columns of data. +** +** See also: [sqlite3_column_count()] +*/ +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes +** KEYWORDS: SQLITE_TEXT +** +** ^(Every value in SQLite has one of five fundamental datatypes: +** +**
    +**
  • 64-bit signed integer +**
  • 64-bit IEEE floating point number +**
  • string +**
  • BLOB +**
  • NULL +**
)^ +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Result Values From A Query +** KEYWORDS: {column access functions} +** +** These routines form the "result set" interface. +** +** ^These routines return information about a single column of the current +** result row of a query. ^In every case the first argument is a pointer +** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] +** that was returned from [sqlite3_prepare_v2()] or one of its variants) +** and the second argument is the index of the column for which information +** should be returned. ^The leftmost column of the result set has the index 0. +** ^The number of columns in the result can be determined using +** [sqlite3_column_count()]. +** +** If the SQL statement does not currently point to a valid row, or if the +** column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** ^The sqlite3_column_type() routine returns the +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. ^The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value +** returned by sqlite3_column_type() is only meaningful if no type +** conversions have occurred as described below. After a type conversion, +** the value returned by sqlite3_column_type() is undefined. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes() returns zero. +** +** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts +** the string to UTF-16 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes16() uses +** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes16() returns zero. +** +** ^The values returned by [sqlite3_column_bytes()] and +** [sqlite3_column_bytes16()] do not include the zero terminators at the end +** of the string. ^For clarity: the values returned by +** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of +** bytes in the string, not the number of characters. +** +** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even empty strings, are always zero-terminated. ^The return +** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer. +** +** ^The object returned by [sqlite3_column_value()] is an +** [unprotected sqlite3_value] object. An unprotected sqlite3_value object +** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()]. +** If the [unprotected sqlite3_value] object returned by +** [sqlite3_column_value()] is used in any other way, including calls +** to routines like [sqlite3_value_int()], [sqlite3_value_text()], +** or [sqlite3_value_bytes()], then the behavior is undefined. +** +** These routines attempt to convert the value where appropriate. ^For +** example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to perform the +** conversion automatically. ^(The following table details the conversions +** that are applied: +** +**
+** +**
Internal
Type 		Requested
Type 		Conversion +** +**
NULL INTEGER Result is 0 +**
NULL FLOAT Result is 0.0 +**
NULL TEXT Result is NULL pointer +**
NULL BLOB Result is NULL pointer +**
INTEGER FLOAT Convert from integer to float +**
INTEGER TEXT ASCII rendering of the integer +**
INTEGER BLOB Same as INTEGER->TEXT +**
FLOAT INTEGER Convert from float to integer +**
FLOAT TEXT ASCII rendering of the float +**
FLOAT BLOB Same as FLOAT->TEXT +**
TEXT INTEGER Use atoi() +**
TEXT FLOAT Use atof() +**
TEXT BLOB No change +**
BLOB INTEGER Convert to TEXT then use atoi() +**
BLOB FLOAT Convert to TEXT then use atof() +**
BLOB TEXT Add a zero terminator if needed +**
+**
)^ +** +** The table above makes reference to standard C library functions atoi() +** and atof(). SQLite does not really use these functions. It has its +** own equivalent internal routines. The atoi() and atof() names are +** used in the table for brevity and because they are familiar to most +** C programmers. +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +**
    +**
  • The initial content is a BLOB and sqlite3_column_text() or +** sqlite3_column_text16() is called. A zero-terminator might +** need to be added to the string.
    • +**
  • The initial content is UTF-8 text and sqlite3_column_bytes16() or +** sqlite3_column_text16() is called. The content must be converted +** to UTF-16.
    • +**
  • The initial content is UTF-16 text and sqlite3_column_bytes() or +** sqlite3_column_text() is called. The content must be converted +** to UTF-8.
    • +**
+** +** ^Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer references will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometimes they +** are not possible and in those cases prior pointers are invalidated. +** +** The safest and easiest to remember policy is to invoke these routines +** in one of the following ways: +** +**
    +**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • +**
+** +** In other words, you should call sqlite3_column_text(), +** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result +** into the desired format, then invoke sqlite3_column_bytes() or +** sqlite3_column_bytes16() to find the size of the result. Do not mix calls +** to sqlite3_column_text() or sqlite3_column_blob() with calls to +** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() +** with calls to sqlite3_column_bytes(). +** +** ^The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. ^The memory space used to hold strings +** and BLOBs is freed automatically. Do not pass the pointers returned +** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** ^(If a memory allocation error occurs during the evaluation of any +** of these routines, a default value is returned. The default value +** is either the integer 0, the floating point number 0.0, or a NULL +** pointer. Subsequent calls to [sqlite3_errcode()] will return +** [SQLITE_NOMEM].)^ +*/ +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object +** +** ^The sqlite3_finalize() function is called to delete a [prepared statement]. +** ^If the most recent evaluation of the statement encountered no errors +** or if the statement is never been evaluated, then sqlite3_finalize() returns +** SQLITE_OK. ^If the most recent evaluation of statement S failed, then +** sqlite3_finalize(S) returns the appropriate [error code] or +** [extended error code]. +** +** ^The sqlite3_finalize(S) routine can be called at any point during +** the life cycle of [prepared statement] S: +** before statement S is ever evaluated, after +** one or more calls to [sqlite3_reset()], or after any call +** to [sqlite3_step()] regardless of whether or not the statement has +** completed execution. +** +** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op. +** +** The application must finalize every [prepared statement] in order to avoid +** resource leaks. It is a grievous error for the application to try to use +** a prepared statement after it has been finalized. Any use of a prepared +** statement after it has been finalized can result in undefined and +** undesirable behavior such as segfaults and heap corruption. +*/ +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object +** +** The sqlite3_reset() function is called to reset a [prepared statement] +** object back to its initial state, ready to be re-executed. +** ^Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +** +** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S +** back to the beginning of its program. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], +** or if [sqlite3_step(S)] has never before been called on S, +** then [sqlite3_reset(S)] returns [SQLITE_OK]. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S indicated an error, then +** [sqlite3_reset(S)] returns an appropriate [error code]. +** +** ^The [sqlite3_reset(S)] interface does not change the values +** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. +*/ +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions +** KEYWORDS: {function creation routines} +** KEYWORDS: {application-defined SQL function} +** KEYWORDS: {application-defined SQL functions} +** +** ^These functions (collectively known as "function creation routines") +** are used to add SQL functions or aggregates or to redefine the behavior +** of existing SQL functions or aggregates. The only differences between +** these routines are the text encoding expected for +** the second parameter (the name of the function being created) +** and the presence or absence of a destructor callback for +** the application data pointer. +** +** ^The first parameter is the [database connection] to which the SQL +** function is to be added. ^If an application uses more than one database +** connection then application-defined SQL functions must be added +** to each database connection separately. +** +** ^The second parameter is the name of the SQL function to be created or +** redefined. ^The length of the name is limited to 255 bytes in a UTF-8 +** representation, exclusive of the zero-terminator. ^Note that the name +** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes. +** ^Any attempt to create a function with a longer name +** will result in [SQLITE_MISUSE] being returned. +** +** ^The third parameter (nArg) +** is the number of arguments that the SQL function or +** aggregate takes. ^If this parameter is -1, then the SQL function or +** aggregate may take any number of arguments between 0 and the limit +** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third +** parameter is less than -1 or greater than 127 then the behavior is +** undefined. +** +** ^The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. Every SQL function implementation must be able to work +** with UTF-8, UTF-16le, or UTF-16be. But some implementations may be +** more efficient with one encoding than another. ^An application may +** invoke sqlite3_create_function() or sqlite3_create_function16() multiple +** times with the same function but with different values of eTextRep. +** ^When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** If there is only a single implementation which does not care what text +** encoding is used, then the fourth argument should be [SQLITE_ANY]. +** +** ^(The fifth parameter is an arbitrary pointer. The implementation of the +** function can gain access to this pointer using [sqlite3_user_data()].)^ +** +** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL function or +** aggregate. ^A scalar SQL function requires an implementation of the xFunc +** callback only; NULL pointers must be passed as the xStep and xFinal +** parameters. ^An aggregate SQL function requires an implementation of xStep +** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing +** SQL function or aggregate, pass NULL pointers for all three function +** callbacks. +** +** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL, +** then it is destructor for the application data pointer. +** The destructor is invoked when the function is deleted, either by being +** overloaded or when the database connection closes.)^ +** ^The destructor is also invoked if the call to +** sqlite3_create_function_v2() fails. +** ^When the destructor callback of the tenth parameter is invoked, it +** is passed a single argument which is a copy of the application data +** pointer which was the fifth parameter to sqlite3_create_function_v2(). +** +** ^It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing preferred text encodings. ^SQLite will use +** the implementation that most closely matches the way in which the +** SQL function is used. ^A function implementation with a non-negative +** nArg parameter is a better match than a function implementation with +** a negative nArg. ^A function where the preferred text encoding +** matches the database encoding is a better +** match than a function where the encoding is different. +** ^A function where the encoding difference is between UTF16le and UTF16be +** is a closer match than a function where the encoding difference is +** between UTF8 and UTF16. +** +** ^Built-in functions may be overloaded by new application-defined functions. +** +** ^An application-defined function is permitted to call other +** SQLite interfaces. However, such calls must not +** close the database connection nor finalize or reset the prepared +** statement in which the function is running. +*/ +SQLITE_API int sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*) +); + +/* +** CAPI3REF: Text Encodings +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 +#define SQLITE_UTF16LE 2 +#define SQLITE_UTF16BE 3 +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* sqlite3_create_function only */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Deprecated Functions +** DEPRECATED +** +** These functions are [deprecated]. In order to maintain +** backwards compatibility with older code, these functions continue +** to be supported. However, new applications should avoid +** the use of these functions. To help encourage people to avoid +** using these functions, we are not going to tell you what they do. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void); +SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void); +SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int), + void*,sqlite3_int64); +#endif + +/* +** CAPI3REF: Obtaining SQL Function Parameter Values +** +** The C-language implementation of SQL functions and aggregates uses +** this set of interface routines to access the parameter values on +** the function or aggregate. +** +** The xFunc (for scalar functions) or xStep (for aggregates) parameters +** to [sqlite3_create_function()] and [sqlite3_create_function16()] +** define callbacks that implement the SQL functions and aggregates. +** The 3rd parameter to these callbacks is an array of pointers to +** [protected sqlite3_value] objects. There is one [sqlite3_value] object for +** each parameter to the SQL function. These routines are used to +** extract values from the [sqlite3_value] objects. +** +** These routines work only with [protected sqlite3_value] objects. +** Any attempt to use these routines on an [unprotected sqlite3_value] +** object results in undefined behavior. +** +** ^These routines work just like the corresponding [column access functions] +** except that these routines take a single [protected sqlite3_value] object +** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. +** +** ^The sqlite3_value_text16() interface extracts a UTF-16 string +** in the native byte-order of the host machine. ^The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF-16 strings as big-endian and little-endian respectively. +** +** ^(The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words, if the value is a string that looks like a number) +** then the conversion is performed. Otherwise no conversion occurs. +** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ +** +** Please pay particular attention to the fact that the pointer returned +** from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the [sqlite3_value*] parameters. +*/ +SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes16(sqlite3_value*); +SQLITE_API double sqlite3_value_double(sqlite3_value*); +SQLITE_API int sqlite3_value_int(sqlite3_value*); +SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*); +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*); +SQLITE_API int sqlite3_value_type(sqlite3_value*); +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context +** +** Implementations of aggregate SQL functions use this +** routine to allocate memory for storing their state. +** +** ^The first time the sqlite3_aggregate_context(C,N) routine is called +** for a particular aggregate function, SQLite +** allocates N of memory, zeroes out that memory, and returns a pointer +** to the new memory. ^On second and subsequent calls to +** sqlite3_aggregate_context() for the same aggregate function instance, +** the same buffer is returned. Sqlite3_aggregate_context() is normally +** called once for each invocation of the xStep callback and then one +** last time when the xFinal callback is invoked. ^(When no rows match +** an aggregate query, the xStep() callback of the aggregate function +** implementation is never called and xFinal() is called exactly once. +** In those cases, sqlite3_aggregate_context() might be called for the +** first time from within xFinal().)^ +** +** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer +** when first called if N is less than or equal to zero or if a memory +** allocate error occurs. +** +** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is +** determined by the N parameter on first successful call. Changing the +** value of N in subsequent call to sqlite3_aggregate_context() within +** the same aggregate function instance will not resize the memory +** allocation.)^ Within the xFinal callback, it is customary to set +** N=0 in calls to sqlite3_aggregate_context(C,N) so that no +** pointless memory allocations occur. +** +** ^SQLite automatically frees the memory allocated by +** sqlite3_aggregate_context() when the aggregate query concludes. +** +** The first parameter must be a copy of the +** [sqlite3_context | SQL function context] that is the first parameter +** to the xStep or xFinal callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions +** +** ^The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +** +** This routine must be called from the same thread in which +** the application-defined function is running. +*/ +SQLITE_API void *sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Database Connection For Functions +** +** ^The sqlite3_context_db_handle() interface returns a copy of +** the pointer to the [database connection] (the 1st parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +*/ +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data +** +** The following two functions may be used by scalar SQL functions to +** associate metadata with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated metadata may be preserved. This may +** be used, for example, to add a regular-expression matching scalar +** function. The compiled version of the regular expression is stored as +** metadata associated with the SQL value passed as the regular expression +** pattern. The compiled regular expression can be reused on multiple +** invocations of the same function so that the original pattern string +** does not need to be recompiled on each invocation. +** +** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata +** associated by the sqlite3_set_auxdata() function with the Nth argument +** value to the application-defined function. ^If no metadata has been ever +** been set for the Nth argument of the function, or if the corresponding +** function parameter has changed since the meta-data was set, +** then sqlite3_get_auxdata() returns a NULL pointer. +** +** ^The sqlite3_set_auxdata() interface saves the metadata +** pointed to by its 3rd parameter as the metadata for the N-th +** argument of the application-defined function. Subsequent +** calls to sqlite3_get_auxdata() might return this data, if it has +** not been destroyed. +** ^If it is not NULL, SQLite will invoke the destructor +** function given by the 4th parameter to sqlite3_set_auxdata() on +** the metadata when the corresponding function parameter changes +** or when the SQL statement completes, whichever comes first. +** +** SQLite is free to call the destructor and drop metadata on any +** parameter of any function at any time. ^The only guarantee is that +** the destructor will be called before the metadata is dropped. +** +** ^(In practice, metadata is preserved between function calls for +** expressions that are constant at compile time. This includes literal +** values and [parameters].)^ +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N); +SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior +** +** These are special values for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. ^If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. ^The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. See ticket #2191. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the [parameter binding] family of +** functions used to bind values to host parameters in prepared statements. +** Refer to the [SQL parameter] documentation for additional information. +** +** ^The sqlite3_result_blob() interface sets the result from +** an application-defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** +** ^The sqlite3_result_zeroblob() interfaces set the result of +** the application-defined function to be a BLOB containing all zero +** bytes and N bytes in size, where N is the value of the 2nd parameter. +** +** ^The sqlite3_result_double() interface sets the result from +** an application-defined function to be a floating point value specified +** by its 2nd argument. +** +** ^The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** ^SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. ^SQLite interprets the error +** message string from sqlite3_result_error() as UTF-8. ^SQLite +** interprets the string from sqlite3_result_error16() as UTF-16 in native +** byte order. ^If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** ^If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** ^The sqlite3_result_error() and sqlite3_result_error16() +** routines make a private copy of the error message text before +** they return. Hence, the calling function can deallocate or +** modify the text after they return without harm. +** ^The sqlite3_result_error_code() function changes the error code +** returned by SQLite as a result of an error in a function. ^By default, +** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() +** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. +** +** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an +** error indicating that a string or BLOB is too long to represent. +** +** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an +** error indicating that a memory allocation failed. +** +** ^The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** ^The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** ^The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** ^The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** ^SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is negative, then SQLite takes result text from the 2nd parameter +** through the first zero character. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. If the 3rd parameter is non-negative, then it +** must be the byte offset into the string where the NUL terminator would +** appear if the string where NUL terminated. If any NUL characters occur +** in the string at a byte offset that is less than the value of the 3rd +** parameter, then the resulting string will contain embedded NULs and the +** result of expressions operating on strings with embedded NULs is undefined. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or BLOB result when it has +** finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces or to +** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite +** assumes that the text or BLOB result is in constant space and does not +** copy the content of the parameter nor call a destructor on the content +** when it has finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained from +** from [sqlite3_malloc()] before it returns. +** +** ^The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy the +** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that the [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** ^A [protected sqlite3_value] object may always be used where an +** [unprotected sqlite3_value] object is required, so either +** kind of [sqlite3_value] object can be used with this interface. +** +** If these routines are called from within the different thread +** than the one containing the application-defined function that received +** the [sqlite3_context] pointer, the results are undefined. +*/ +SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_double(sqlite3_context*, double); +SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int); +SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int); +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*); +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*); +SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +SQLITE_API void sqlite3_result_null(sqlite3_context*); +SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*); +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n); + +/* +** CAPI3REF: Define New Collating Sequences +** +** ^These functions add, remove, or modify a [collation] associated +** with the [database connection] specified as the first argument. +** +** ^The name of the collation is a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string in native byte order for sqlite3_create_collation16(). +** ^Collation names that compare equal according to [sqlite3_strnicmp()] are +** considered to be the same name. +** +** ^(The third argument (eTextRep) must be one of the constants: +**
    +**
  • [SQLITE_UTF8], +**
  • [SQLITE_UTF16LE], +**
  • [SQLITE_UTF16BE], +**
  • [SQLITE_UTF16], or +**
  • [SQLITE_UTF16_ALIGNED]. +**
)^ +** ^The eTextRep argument determines the encoding of strings passed +** to the collating function callback, xCallback. +** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep +** force strings to be UTF16 with native byte order. +** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin +** on an even byte address. +** +** ^The fourth argument, pArg, is an application data pointer that is passed +** through as the first argument to the collating function callback. +** +** ^The fifth argument, xCallback, is a pointer to the collating function. +** ^Multiple collating functions can be registered using the same name but +** with different eTextRep parameters and SQLite will use whichever +** function requires the least amount of data transformation. +** ^If the xCallback argument is NULL then the collating function is +** deleted. ^When all collating functions having the same name are deleted, +** that collation is no longer usable. +** +** ^The collating function callback is invoked with a copy of the pArg +** application data pointer and with two strings in the encoding specified +** by the eTextRep argument. The collating function must return an +** integer that is negative, zero, or positive +** if the first string is less than, equal to, or greater than the second, +** respectively. A collating function must always return the same answer +** given the same inputs. If two or more collating functions are registered +** to the same collation name (using different eTextRep values) then all +** must give an equivalent answer when invoked with equivalent strings. +** The collating function must obey the following properties for all +** strings A, B, and C: +** +**
    +**
  1. If A==B then B==A. +**
  2. If A==B and B==C then A==C. +**
  3. If A<B THEN B>A. +**
  4. If A<B and B<C then A<C. +**
+** +** If a collating function fails any of the above constraints and that +** collating function is registered and used, then the behavior of SQLite +** is undefined. +** +** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** with the addition that the xDestroy callback is invoked on pArg when +** the collating function is deleted. +** ^Collating functions are deleted when they are overridden by later +** calls to the collation creation functions or when the +** [database connection] is closed using [sqlite3_close()]. +** +** ^The xDestroy callback is not called if the +** sqlite3_create_collation_v2() function fails. Applications that invoke +** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should +** check the return code and dispose of the application data pointer +** themselves rather than expecting SQLite to deal with it for them. +** This is different from every other SQLite interface. The inconsistency +** is unfortunate but cannot be changed without breaking backwards +** compatibility. +** +** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. +*/ +SQLITE_API int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); +SQLITE_API int sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_collation16( + sqlite3*, + const void *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks +** +** ^To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** [database connection] to be invoked whenever an undefined collation +** sequence is required. +** +** ^If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, +** the names are passed as UTF-16 in machine native byte order. +** ^A call to either function replaces the existing collation-needed callback. +** +** ^(When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], +** or [SQLITE_UTF16LE], indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence.)^ +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +SQLITE_API int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +SQLITE_API int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +#ifdef SQLITE_HAS_CODEC +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +SQLITE_API int sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +SQLITE_API int sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); + +/* +** Specify the activation key for a SEE database. Unless +** activated, none of the SEE routines will work. +*/ +SQLITE_API void sqlite3_activate_see( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +#ifdef SQLITE_ENABLE_CEROD +/* +** Specify the activation key for a CEROD database. Unless +** activated, none of the CEROD routines will work. +*/ +SQLITE_API void sqlite3_activate_cerod( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +/* +** CAPI3REF: Suspend Execution For A Short Time +** +** The sqlite3_sleep() function causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** ^SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. If the xSleep() method +** of the default VFS is not implemented correctly, or not implemented at +** all, then the behavior of sqlite3_sleep() may deviate from the description +** in the previous paragraphs. +*/ +SQLITE_API int sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all temporary files +** created by SQLite when using a built-in [sqlite3_vfs | VFS] +** will be placed in that directory.)^ ^If this variable +** is a NULL pointer, then SQLite performs a search for an appropriate +** temporary file directory. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [temp_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [temp_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [temp_store_directory pragma] should be avoided. +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling [sqlite3_open] or [sqlite3_open_v2]. Otherwise, various +** features that require the use of temporary files may fail. Here is an +** example of how to do this using C++ with the Windows Runtime: +** +** 
+** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
+**       TemporaryFolder->Path->Data();
+** char zPathBuf[MAX_PATH + 1];
+** memset(zPathBuf, 0, sizeof(zPathBuf));
+** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
+**       NULL, NULL);
+** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
+**
+*/ +SQLITE_API SQLITE_EXTERN char *sqlite3_temp_directory; + +/* +** CAPI3REF: Name Of The Folder Holding Database Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all database files +** specified with a relative pathname and created or accessed by +** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed +** to be relative to that directory.)^ ^If this variable is a NULL +** pointer, then SQLite assumes that all database files specified +** with a relative pathname are relative to the current directory +** for the process. Only the windows VFS makes use of this global +** variable; it is ignored by the unix VFS. +** +** Changing the value of this variable while a database connection is +** open can result in a corrupt database. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [data_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [data_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [data_store_directory pragma] should be avoided. +*/ +SQLITE_API SQLITE_EXTERN char *sqlite3_data_directory; + +/* +** CAPI3REF: Test For Auto-Commit Mode +** KEYWORDS: {autocommit mode} +** +** ^The sqlite3_get_autocommit() interface returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. ^Autocommit mode is on by default. +** ^Autocommit mode is disabled by a [BEGIN] statement. +** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. +** +** If certain kinds of errors occur on a statement within a multi-statement +** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. The only way to +** find out whether SQLite automatically rolled back the transaction after +** an error is to use this function. +** +** If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. +*/ +SQLITE_API int sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement +** +** ^The sqlite3_db_handle interface returns the [database connection] handle +** to which a [prepared statement] belongs. ^The [database connection] +** returned by sqlite3_db_handle is the same [database connection] +** that was the first argument +** to the [sqlite3_prepare_v2()] call (or its variants) that was used to +** create the statement in the first place. +*/ +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + +/* +** CAPI3REF: Return The Filename For A Database Connection +** +** ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename +** associated with database N of connection D. ^The main database file +** has the name "main". If there is no attached database N on the database +** connection D, or if database N is a temporary or in-memory database, then +** a NULL pointer is returned. +** +** ^The filename returned by this function is the output of the +** xFullPathname method of the [VFS]. ^In other words, the filename +** will be an absolute pathname, even if the filename used +** to open the database originally was a URI or relative pathname. +*/ +SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine if a database is read-only +** +** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N +** of connection D is read-only, 0 if it is read/write, or -1 if N is not +** the name of a database on connection D. +*/ +SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Find the next prepared statement +** +** ^This interface returns a pointer to the next [prepared statement] after +** pStmt associated with the [database connection] pDb. ^If pStmt is NULL +** then this interface returns a pointer to the first prepared statement +** associated with the database connection pDb. ^If no prepared statement +** satisfies the conditions of this routine, it returns NULL. +** +** The [database connection] pointer D in a call to +** [sqlite3_next_stmt(D,S)] must refer to an open database +** connection and in particular must not be a NULL pointer. +*/ +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks +** +** ^The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is [COMMIT | committed]. +** ^Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** ^The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. +** ^Any callback set by a previous call to sqlite3_rollback_hook() +** for the same database connection is overridden. +** ^The pArg argument is passed through to the callback. +** ^If the callback on a commit hook function returns non-zero, +** then the commit is converted into a rollback. +** +** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions +** return the P argument from the previous call of the same function +** on the same [database connection] D, or NULL for +** the first call for each function on D. +** +** The commit and rollback hook callbacks are not reentrant. +** The callback implementation must not do anything that will modify +** the database connection that invoked the callback. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the commit +** or rollback hook in the first place. +** Note that running any other SQL statements, including SELECT statements, +** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify +** the database connections for the meaning of "modify" in this paragraph. +** +** ^Registering a NULL function disables the callback. +** +** ^When the commit hook callback routine returns zero, the [COMMIT] +** operation is allowed to continue normally. ^If the commit hook +** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. +** ^The rollback hook is invoked on a rollback that results from a commit +** hook returning non-zero, just as it would be with any other rollback. +** +** ^For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** ^The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** +** See also the [sqlite3_update_hook()] interface. +*/ +SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Data Change Notification Callbacks +** +** ^The sqlite3_update_hook() interface registers a callback function +** with the [database connection] identified by the first argument +** to be invoked whenever a row is updated, inserted or deleted. +** ^Any callback set by a previous call to this function +** for the same database connection is overridden. +** +** ^The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted. +** ^The first argument to the callback is a copy of the third argument +** to sqlite3_update_hook(). +** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], +** or [SQLITE_UPDATE], depending on the operation that caused the callback +** to be invoked. +** ^The third and fourth arguments to the callback contain pointers to the +** database and table name containing the affected row. +** ^The final callback parameter is the [rowid] of the row. +** ^In the case of an update, this is the [rowid] after the update takes place. +** +** ^(The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_master and sqlite_sequence).)^ +** +** ^In the current implementation, the update hook +** is not invoked when duplication rows are deleted because of an +** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook +** invoked when rows are deleted using the [truncate optimization]. +** The exceptions defined in this paragraph might change in a future +** release of SQLite. +** +** The update hook implementation must not do anything that will modify +** the database connection that invoked the update hook. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the update hook. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^The sqlite3_update_hook(D,C,P) function +** returns the P argument from the previous call +** on the same [database connection] D, or NULL for +** the first call on D. +** +** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()] +** interfaces. +*/ +SQLITE_API void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache +** +** ^(This routine enables or disables the sharing of the database cache +** and schema data structures between [database connection | connections] +** to the same database. Sharing is enabled if the argument is true +** and disabled if the argument is false.)^ +** +** ^Cache sharing is enabled and disabled for an entire process. +** This is a change as of SQLite version 3.5.0. In prior versions of SQLite, +** sharing was enabled or disabled for each thread separately. +** +** ^(The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** Existing database connections continue use the sharing mode +** that was in effect at the time they were opened.)^ +** +** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled +** successfully. An [error code] is returned otherwise.)^ +** +** ^Shared cache is disabled by default. But this might change in +** future releases of SQLite. Applications that care about shared +** cache setting should set it explicitly. +** +** This interface is threadsafe on processors where writing a +** 32-bit integer is atomic. +** +** See Also: [SQLite Shared-Cache Mode] +*/ +SQLITE_API int sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory +** +** ^The sqlite3_release_memory() interface attempts to free N bytes +** of heap memory by deallocating non-essential memory allocations +** held by the database library. Memory used to cache database +** pages to improve performance is an example of non-essential memory. +** ^sqlite3_release_memory() returns the number of bytes actually freed, +** which might be more or less than the amount requested. +** ^The sqlite3_release_memory() routine is a no-op returning zero +** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** See also: [sqlite3_db_release_memory()] +*/ +SQLITE_API int sqlite3_release_memory(int); + +/* +** CAPI3REF: Free Memory Used By A Database Connection +** +** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap +** memory as possible from database connection D. Unlike the +** [sqlite3_release_memory()] interface, this interface is effect even +** when then [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is +** omitted. +** +** See also: [sqlite3_release_memory()] +*/ +SQLITE_API int sqlite3_db_release_memory(sqlite3*); + +/* +** CAPI3REF: Impose A Limit On Heap Size +** +** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the +** soft limit on the amount of heap memory that may be allocated by SQLite. +** ^SQLite strives to keep heap memory utilization below the soft heap +** limit by reducing the number of pages held in the page cache +** as heap memory usages approaches the limit. +** ^The soft heap limit is "soft" because even though SQLite strives to stay +** below the limit, it will exceed the limit rather than generate +** an [SQLITE_NOMEM] error. In other words, the soft heap limit +** is advisory only. +** +** ^The return value from sqlite3_soft_heap_limit64() is the size of +** the soft heap limit prior to the call, or negative in the case of an +** error. ^If the argument N is negative +** then no change is made to the soft heap limit. Hence, the current +** size of the soft heap limit can be determined by invoking +** sqlite3_soft_heap_limit64() with a negative argument. +** +** ^If the argument N is zero then the soft heap limit is disabled. +** +** ^(The soft heap limit is not enforced in the current implementation +** if one or more of following conditions are true: +** +**
    +**
  • The soft heap limit is set to zero. +**
  • Memory accounting is disabled using a combination of the +** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and +** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option. +**
  • An alternative page cache implementation is specified using +** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...). +**
  • The page cache allocates from its own memory pool supplied +** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than +** from the heap. +**
)^ +** +** Beginning with SQLite version 3.7.3, the soft heap limit is enforced +** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT] +** compile-time option is invoked. With [SQLITE_ENABLE_MEMORY_MANAGEMENT], +** the soft heap limit is enforced on every memory allocation. Without +** [SQLITE_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced +** when memory is allocated by the page cache. Testing suggests that because +** the page cache is the predominate memory user in SQLite, most +** applications will achieve adequate soft heap limit enforcement without +** the use of [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** The circumstances under which SQLite will enforce the soft heap limit may +** changes in future releases of SQLite. +*/ +SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N); + +/* +** CAPI3REF: Deprecated Soft Heap Limit Interface +** DEPRECATED +** +** This is a deprecated version of the [sqlite3_soft_heap_limit64()] +** interface. This routine is provided for historical compatibility +** only. All new applications should use the +** [sqlite3_soft_heap_limit64()] interface rather than this one. +*/ +SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N); + + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table +** +** ^This routine returns metadata about a specific column of a specific +** database table accessible using the [database connection] handle +** passed as the first function argument. +** +** ^The column is identified by the second, third and fourth parameters to +** this function. ^The second parameter is either the name of the database +** (i.e. "main", "temp", or an attached database) containing the specified +** table or NULL. ^If it is NULL, then all attached databases are searched +** for the table using the same algorithm used by the database engine to +** resolve unqualified table references. +** +** ^The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. Neither of these parameters +** may be NULL. +** +** ^Metadata is returned by writing to the memory locations passed as the 5th +** and subsequent parameters to this function. ^Any of these arguments may be +** NULL, in which case the corresponding element of metadata is omitted. +** +** ^(
+** +**
Parameter Output
Type 		Description +** +**
5th const char* Data type +**
6th const char* Name of default collation sequence +**
7th int True if column has a NOT NULL constraint +**
8th int True if column is part of the PRIMARY KEY +**
9th int True if column is [AUTOINCREMENT] +**
+**
)^ +** +** ^The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid only until the next +** call to any SQLite API function. +** +** ^If the specified table is actually a view, an [error code] is returned. +** +** ^If the specified column is "rowid", "oid" or "_rowid_" and an +** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. ^(If there is no +** explicitly declared [INTEGER PRIMARY KEY] column, then the output +** parameters are set as follows: +** +** 
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
)^ +** +** ^(This function may load one or more schemas from database files. If an +** error occurs during this process, or if the requested table or column +** cannot be found, an [error code] is returned and an error message left +** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^ +** +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined. +*/ +SQLITE_API int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension +** +** ^This interface loads an SQLite extension library from the named file. +** +** ^The sqlite3_load_extension() interface attempts to load an +** SQLite extension library contained in the file zFile. +** +** ^The entry point is zProc. +** ^zProc may be 0, in which case the name of the entry point +** defaults to "sqlite3_extension_init". +** ^The sqlite3_load_extension() interface returns +** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** ^If an error occurs and pzErrMsg is not 0, then the +** [sqlite3_load_extension()] interface shall attempt to +** fill *pzErrMsg with error message text stored in memory +** obtained from [sqlite3_malloc()]. The calling function +** should free this memory by calling [sqlite3_free()]. +** +** ^Extension loading must be enabled using +** [sqlite3_enable_load_extension()] prior to calling this API, +** otherwise an error will be returned. +** +** See also the [load_extension() SQL function]. +*/ +SQLITE_API int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading +** +** ^So as not to open security holes in older applications that are +** unprepared to deal with extension loading, and as a means of disabling +** extension loading while evaluating user-entered SQL, the following API +** is provided to turn the [sqlite3_load_extension()] mechanism on and off. +** +** ^Extension loading is off by default. See ticket #1863. +** ^Call the sqlite3_enable_load_extension() routine with onoff==1 +** to turn extension loading on and call it with onoff==0 to turn +** it back off again. +*/ +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Automatically Load Statically Linked Extensions +** +** ^This interface causes the xEntryPoint() function to be invoked for +** each new [database connection] that is created. The idea here is that +** xEntryPoint() is the entry point for a statically linked SQLite extension +** that is to be automatically loaded into all new database connections. +** +** ^(Even though the function prototype shows that xEntryPoint() takes +** no arguments and returns void, SQLite invokes xEntryPoint() with three +** arguments and expects and integer result as if the signature of the +** entry point where as follows: +** +** 
+**    int xEntryPoint(
+**      sqlite3 *db,
+**      const char **pzErrMsg,
+**      const struct sqlite3_api_routines *pThunk
+**    );
+**
)^ +** +** If the xEntryPoint routine encounters an error, it should make *pzErrMsg +** point to an appropriate error message (obtained from [sqlite3_mprintf()]) +** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg +** is NULL before calling the xEntryPoint(). ^SQLite will invoke +** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any +** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()], +** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail. +** +** ^Calling sqlite3_auto_extension(X) with an entry point X that is already +** on the list of automatic extensions is a harmless no-op. ^No entry point +** will be called more than once for each database connection that is opened. +** +** See also: [sqlite3_reset_auto_extension()]. +*/ +SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void)); + +/* +** CAPI3REF: Reset Automatic Extension Loading +** +** ^This interface disables all automatic extensions previously +** registered using [sqlite3_auto_extension()]. +*/ +SQLITE_API void sqlite3_reset_auto_extension(void); + +/* +** The interface to the virtual-table mechanism is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** CAPI3REF: Virtual Table Object +** KEYWORDS: sqlite3_module {virtual table module} +** +** This structure, sometimes called a "virtual table module", +** defines the implementation of a [virtual tables]. +** This structure consists mostly of methods for the module. +** +** ^A virtual table module is created by filling in a persistent +** instance of this structure and passing a pointer to that instance +** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. +** ^The registration remains valid until it is replaced by a different +** module or until the [database connection] closes. The content +** of this structure must not change while it is registered with +** any database connection. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); + /* The methods above are in version 1 of the sqlite_module object. Those + ** below are for version 2 and greater. */ + int (*xSavepoint)(sqlite3_vtab *pVTab, int); + int (*xRelease)(sqlite3_vtab *pVTab, int); + int (*xRollbackTo)(sqlite3_vtab *pVTab, int); +}; + +/* +** CAPI3REF: Virtual Table Indexing Information +** KEYWORDS: sqlite3_index_info +** +** The sqlite3_index_info structure and its substructures is used as part +** of the [virtual table] interface to +** pass information into and receive the reply from the [xBestIndex] +** method of a [virtual table module]. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** ^(The aConstraint[] array records WHERE clause constraints of the form: +** +**
column OP expr
+** +** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +** stored in aConstraint[].op using one of the +** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +** ^(The index of the column is stored in +** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot.)^ +** +** ^The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** ^The aConstraint[] array only reports WHERE clause terms that are +** relevant to the particular virtual table being queried. +** +** ^Information about the ORDER BY clause is stored in aOrderBy[]. +** ^Each term of aOrderBy records a column of the ORDER BY clause. +** +** The [xBestIndex] method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. ^If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and is not checked again by SQLite.)^ +** +** ^The idxNum and idxPtr values are recorded and passed into the +** [xFilter] method. +** ^[sqlite3_free()] is used to free idxPtr if and only if +** needToFreeIdxPtr is true. +** +** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** ^The estimatedCost value is an estimate of the cost of doing the +** particular lookup. A full scan of a table with N entries should have +** a cost of N. A binary search of a table of N entries should have a +** cost of approximately log(N). +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column on left-hand side of constraint */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ +}; + +/* +** CAPI3REF: Virtual Table Constraint Operator Codes +** +** These macros defined the allowed values for the +** [sqlite3_index_info].aConstraint[].op field. Each value represents +** an operator that is part of a constraint term in the wHERE clause of +** a query that uses a [virtual table]. +*/ +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 + +/* +** CAPI3REF: Register A Virtual Table Implementation +** +** ^These routines are used to register a new [virtual table module] name. +** ^Module names must be registered before +** creating a new [virtual table] using the module and before using a +** preexisting [virtual table] for the module. +** +** ^The module name is registered on the [database connection] specified +** by the first parameter. ^The name of the module is given by the +** second parameter. ^The third parameter is a pointer to +** the implementation of the [virtual table module]. ^The fourth +** parameter is an arbitrary client data pointer that is passed through +** into the [xCreate] and [xConnect] methods of the virtual table module +** when a new virtual table is be being created or reinitialized. +** +** ^The sqlite3_create_module_v2() interface has a fifth parameter which +** is a pointer to a destructor for the pClientData. ^SQLite will +** invoke the destructor function (if it is not NULL) when SQLite +** no longer needs the pClientData pointer. ^The destructor will also +** be invoked if the call to sqlite3_create_module_v2() fails. +** ^The sqlite3_create_module() +** interface is equivalent to sqlite3_create_module_v2() with a NULL +** destructor. +*/ +SQLITE_API int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData /* Client data for xCreate/xConnect */ +); +SQLITE_API int sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** CAPI3REF: Virtual Table Instance Object +** KEYWORDS: sqlite3_vtab +** +** Every [virtual table module] implementation uses a subclass +** of this object to describe a particular instance +** of the [virtual table]. Each subclass will +** be tailored to the specific needs of the module implementation. +** The purpose of this superclass is to define certain fields that are +** common to all module implementations. +** +** ^Virtual tables methods can set an error message by assigning a +** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should +** take care that any prior string is freed by a call to [sqlite3_free()] +** prior to assigning a new string to zErrMsg. ^After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* NO LONGER USED */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Virtual Table Cursor Object +** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} +** +** Every [virtual table module] implementation uses a subclass of the +** following structure to describe cursors that point into the +** [virtual table] and are used +** to loop through the virtual table. Cursors are created using the +** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed +** by the [sqlite3_module.xClose | xClose] method. Cursors are used +** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods +** of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Declare The Schema Of A Virtual Table +** +** ^The [xCreate] and [xConnect] methods of a +** [virtual table module] call this interface +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL); + +/* +** CAPI3REF: Overload A Function For A Virtual Table +** +** ^(Virtual tables can provide alternative implementations of functions +** using the [xFindFunction] method of the [virtual table module]. +** But global versions of those functions +** must exist in order to be overloaded.)^ +** +** ^(This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created.)^ ^The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a placeholder function that can be overloaded +** by a [virtual table]. +*/ +SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** The interface to the virtual-table mechanism defined above (back up +** to a comment remarkably similar to this one) is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** CAPI3REF: A Handle To An Open BLOB +** KEYWORDS: {BLOB handle} {BLOB handles} +** +** An instance of this object represents an open BLOB on which +** [sqlite3_blob_open | incremental BLOB I/O] can be performed. +** ^Objects of this type are created by [sqlite3_blob_open()] +** and destroyed by [sqlite3_blob_close()]. +** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the BLOB. +** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O +** +** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located +** in row iRow, column zColumn, table zTable in database zDb; +** in other words, the same BLOB that would be selected by: +** +** 
+**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
+**
)^ +** +** ^If the flags parameter is non-zero, then the BLOB is opened for read +** and write access. ^If it is zero, the BLOB is opened for read access. +** ^It is not possible to open a column that is part of an index or primary +** key for writing. ^If [foreign key constraints] are enabled, it is +** not possible to open a column that is part of a [child key] for writing. +** +** ^Note that the database name is not the filename that contains +** the database but rather the symbolic name of the database that +** appears after the AS keyword when the database is connected using [ATTACH]. +** ^For the main database file, the database name is "main". +** ^For TEMP tables, the database name is "temp". +** +** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written +** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set +** to be a null pointer.)^ +** ^This function sets the [database connection] error code and message +** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related +** functions. ^Note that the *ppBlob variable is always initialized in a +** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob +** regardless of the success or failure of this routine. +** +** ^(If the row that a BLOB handle points to is modified by an +** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects +** then the BLOB handle is marked as "expired". +** This is true if any column of the row is changed, even a column +** other than the one the BLOB handle is open on.)^ +** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for +** an expired BLOB handle fail with a return code of [SQLITE_ABORT]. +** ^(Changes written into a BLOB prior to the BLOB expiring are not +** rolled back by the expiration of the BLOB. Such changes will eventually +** commit if the transaction continues to completion.)^ +** +** ^Use the [sqlite3_blob_bytes()] interface to determine the size of +** the opened blob. ^The size of a blob may not be changed by this +** interface. Use the [UPDATE] SQL command to change the size of a +** blob. +** +** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces +** and the built-in [zeroblob] SQL function can be used, if desired, +** to create an empty, zero-filled blob in which to read or write using +** this interface. +** +** To avoid a resource leak, every open [BLOB handle] should eventually +** be released by a call to [sqlite3_blob_close()]. +*/ +SQLITE_API int sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Move a BLOB Handle to a New Row +** +** ^This function is used to move an existing blob handle so that it points +** to a different row of the same database table. ^The new row is identified +** by the rowid value passed as the second argument. Only the row can be +** changed. ^The database, table and column on which the blob handle is open +** remain the same. Moving an existing blob handle to a new row can be +** faster than closing the existing handle and opening a new one. +** +** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] - +** it must exist and there must be either a blob or text value stored in +** the nominated column.)^ ^If the new row is not present in the table, or if +** it does not contain a blob or text value, or if another error occurs, an +** SQLite error code is returned and the blob handle is considered aborted. +** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or +** [sqlite3_blob_reopen()] on an aborted blob handle immediately return +** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle +** always returns zero. +** +** ^This function sets the database handle error code and message. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64); + +/* +** CAPI3REF: Close A BLOB Handle +** +** ^Closes an open [BLOB handle]. +** +** ^Closing a BLOB shall cause the current transaction to commit +** if there are no other BLOBs, no pending prepared statements, and the +** database connection is in [autocommit mode]. +** ^If any writes were made to the BLOB, they might be held in cache +** until the close operation if they will fit. +** +** ^(Closing the BLOB often forces the changes +** out to disk and so if any I/O errors occur, they will likely occur +** at the time when the BLOB is closed. Any errors that occur during +** closing are reported as a non-zero return value.)^ +** +** ^(The BLOB is closed unconditionally. Even if this routine returns +** an error code, the BLOB is still closed.)^ +** +** ^Calling this routine with a null pointer (such as would be returned +** by a failed call to [sqlite3_blob_open()]) is a harmless no-op. +*/ +SQLITE_API int sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB +** +** ^Returns the size in bytes of the BLOB accessible via the +** successfully opened [BLOB handle] in its only argument. ^The +** incremental blob I/O routines can only read or overwriting existing +** blob content; they cannot change the size of a blob. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +*/ +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally +** +** ^(This function is used to read data from an open [BLOB handle] into a +** caller-supplied buffer. N bytes of data are copied into buffer Z +** from the open BLOB, starting at offset iOffset.)^ +** +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is +** less than zero, [SQLITE_ERROR] is returned and no data is read. +** ^The size of the blob (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to read from an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. +** +** ^(On success, sqlite3_blob_read() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally +** +** ^This function is used to write data into an open [BLOB handle] from a +** caller-supplied buffer. ^N bytes of data are copied from the buffer Z +** into the open BLOB, starting at offset iOffset. +** +** ^If the [BLOB handle] passed as the first argument was not opened for +** writing (the flags parameter to [sqlite3_blob_open()] was zero), +** this function returns [SQLITE_READONLY]. +** +** ^This function may only modify the contents of the BLOB; it is +** not possible to increase the size of a BLOB using this API. +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is written. ^If N is +** less than zero [SQLITE_ERROR] is returned and no data is written. +** The size of the BLOB (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to write to an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred +** before the [BLOB handle] expired are not rolled back by the +** expiration of the handle, though of course those changes might +** have been overwritten by the statement that expired the BLOB handle +** or by other independent statements. +** +** ^(On success, sqlite3_blob_write() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_read()]. +*/ +SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most SQLite builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. +** ^Names are case sensitive. +** ^Names are zero-terminated UTF-8 strings. +** ^If there is no match, a NULL pointer is returned. +** ^If zVfsName is NULL then the default VFS is returned. +** +** ^New VFSes are registered with sqlite3_vfs_register(). +** ^Each new VFS becomes the default VFS if the makeDflt flag is set. +** ^The same VFS can be registered multiple times without injury. +** ^To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. If two different VFSes with the +** same name are registered, the behavior is undefined. If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. +** ^(If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary.)^ +*/ +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. ^(The following +** implementations are available in the SQLite core: +** +**
    +**
  • SQLITE_MUTEX_PTHREADS +**
  • SQLITE_MUTEX_W32 +**
  • SQLITE_MUTEX_NOOP +**
)^ +** +** ^The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. ^The SQLITE_MUTEX_PTHREADS and +** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix +** and Windows. +** +** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. In this case the +** application must supply a custom mutex implementation using the +** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function +** before calling sqlite3_initialize() or any other public sqlite3_ +** function that calls sqlite3_initialize().)^ +** +** ^The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. ^If it returns NULL +** that means that a mutex could not be allocated. ^SQLite +** will unwind its stack and return an error. ^(The argument +** to sqlite3_mutex_alloc() is one of these integer constants: +** +**
    +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MASTER +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_MEM2 +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_LRU2 +**
)^ +** +** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) +** cause sqlite3_mutex_alloc() to create +** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. ^SQLite will only request a recursive mutex in +** cases where it really needs one. ^If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other +** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return +** a pointer to a static preexisting mutex. ^Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. ^But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +** +** ^The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. ^SQLite is careful to deallocate every +** dynamic mutex that it allocates. The dynamic mutexes must not be in +** use when they are deallocated. Attempting to deallocate a static +** mutex results in undefined behavior. ^SQLite never deallocates +** a static mutex. +** +** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. ^If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] +** upon successful entry. ^(Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter.)^ ^(If the same thread tries to enter any other +** kind of mutex more than once, the behavior is undefined. +** SQLite will never exhibit +** such behavior in its own use of mutexes.)^ +** +** ^(Some systems (for example, Windows 95) do not support the operation +** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() +** will always return SQLITE_BUSY. The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^ +** +** ^The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. ^(The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. SQLite will +** never do either.)^ +** +** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or +** sqlite3_mutex_leave() is a NULL pointer, then all three routines +** behave as no-ops. +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int); +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Methods Object +** +** An instance of this structure defines the low-level routines +** used to allocate and use mutexes. +** +** Usually, the default mutex implementations provided by SQLite are +** sufficient, however the user has the option of substituting a custom +** implementation for specialized deployments or systems for which SQLite +** does not provide a suitable implementation. In this case, the user +** creates and populates an instance of this structure to pass +** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +** Additionally, an instance of this structure can be used as an +** output variable when querying the system for the current mutex +** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +** +** ^The xMutexInit method defined by this structure is invoked as +** part of system initialization by the sqlite3_initialize() function. +** ^The xMutexInit routine is called by SQLite exactly once for each +** effective call to [sqlite3_initialize()]. +** +** ^The xMutexEnd method defined by this structure is invoked as +** part of system shutdown by the sqlite3_shutdown() function. The +** implementation of this method is expected to release all outstanding +** resources obtained by the mutex methods implementation, especially +** those obtained by the xMutexInit method. ^The xMutexEnd() +** interface is invoked exactly once for each call to [sqlite3_shutdown()]. +** +** ^(The remaining seven methods defined by this structure (xMutexAlloc, +** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +** xMutexNotheld) implement the following interfaces (respectively): +** +**
    +**
  • [sqlite3_mutex_alloc()]
    • +**
  • [sqlite3_mutex_free()]
    • +**
  • [sqlite3_mutex_enter()]
    • +**
  • [sqlite3_mutex_try()]
    • +**
  • [sqlite3_mutex_leave()]
    • +**
  • [sqlite3_mutex_held()]
    • +**
  • [sqlite3_mutex_notheld()]
    • +**
)^ +** +** The only difference is that the public sqlite3_XXX functions enumerated +** above silently ignore any invocations that pass a NULL pointer instead +** of a valid mutex handle. The implementations of the methods defined +** by this structure are not required to handle this case, the results +** of passing a NULL pointer instead of a valid mutex handle are undefined +** (i.e. it is acceptable to provide an implementation that segfaults if +** it is passed a NULL pointer). +** +** The xMutexInit() method must be threadsafe. ^It must be harmless to +** invoke xMutexInit() multiple times within the same process and without +** intervening calls to xMutexEnd(). Second and subsequent calls to +** xMutexInit() must be no-ops. +** +** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory +** allocation for a static mutex. ^However xMutexAlloc() may use SQLite +** memory allocation for a fast or recursive mutex. +** +** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +** called, but only if the prior call to xMutexInit returned SQLITE_OK. +** If xMutexInit fails in any way, it is expected to clean up after itself +** prior to returning. +*/ +typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; +struct sqlite3_mutex_methods { + int (*xMutexInit)(void); + int (*xMutexEnd)(void); + sqlite3_mutex *(*xMutexAlloc)(int); + void (*xMutexFree)(sqlite3_mutex *); + void (*xMutexEnter)(sqlite3_mutex *); + int (*xMutexTry)(sqlite3_mutex *); + void (*xMutexLeave)(sqlite3_mutex *); + int (*xMutexHeld)(sqlite3_mutex *); + int (*xMutexNotheld)(sqlite3_mutex *); +}; + +/* +** CAPI3REF: Mutex Verification Routines +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. ^The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. ^The SQLite core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. ^External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** ^These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. +** +** ^The implementation is not required to provide versions of these +** routines that actually work. If the implementation does not provide working +** versions of these routines, it should at least provide stubs that always +** return true so that one does not get spurious assertion failures. +** +** ^If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. ^The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +#ifndef NDEBUG +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*); +#endif + +/* +** CAPI3REF: Mutex Types +** +** The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. +** +** The set of static mutexes may change from one SQLite release to the +** next. Applications that override the built-in mutex logic must be +** prepared to accommodate additional static mutexes. +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MASTER 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ +#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */ + +/* +** CAPI3REF: Retrieve the mutex for a database connection +** +** ^This interface returns a pointer the [sqlite3_mutex] object that +** serializes access to the [database connection] given in the argument +** when the [threading mode] is Serialized. +** ^If the [threading mode] is Single-thread or Multi-thread then this +** routine returns a NULL pointer. +*/ +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*); + +/* +** CAPI3REF: Low-Level Control Of Database Files +** +** ^The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. ^The +** name of the database is "main" for the main database or "temp" for the +** TEMP database, or the name that appears after the AS keyword for +** databases that are added using the [ATTACH] SQL command. +** ^A NULL pointer can be used in place of "main" to refer to the +** main database file. +** ^The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. ^The return value of the xFileControl +** method becomes the return value of this routine. +** +** ^The SQLITE_FCNTL_FILE_POINTER value for the op parameter causes +** a pointer to the underlying [sqlite3_file] object to be written into +** the space pointed to by the 4th parameter. ^The SQLITE_FCNTL_FILE_POINTER +** case is a short-circuit path which does not actually invoke the +** underlying sqlite3_io_methods.xFileControl method. +** +** ^If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. ^This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. The underlying xFileControl method might +** also return SQLITE_ERROR. There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. +** +** See also: [SQLITE_FCNTL_LOCKSTATE] +*/ +SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/* +** CAPI3REF: Testing Interface +** +** ^The sqlite3_test_control() interface is used to read out internal +** state of SQLite and to inject faults into SQLite for testing +** purposes. ^The first parameter is an operation code that determines +** the number, meaning, and operation of all subsequent parameters. +** +** This interface is not for use by applications. It exists solely +** for verifying the correct operation of the SQLite library. Depending +** on how the SQLite library is compiled, this interface might not exist. +** +** The details of the operation codes, their meanings, the parameters +** they take, and what they do are all subject to change without notice. +** Unlike most of the SQLite API, this function is not guaranteed to +** operate consistently from one release to the next. +*/ +SQLITE_API int sqlite3_test_control(int op, ...); + +/* +** CAPI3REF: Testing Interface Operation Codes +** +** These constants are the valid operation code parameters used +** as the first argument to [sqlite3_test_control()]. +** +** These parameters and their meanings are subject to change +** without notice. These values are for testing purposes only. +** Applications should not use any of these parameters or the +** [sqlite3_test_control()] interface. +*/ +#define SQLITE_TESTCTRL_FIRST 5 +#define SQLITE_TESTCTRL_PRNG_SAVE 5 +#define SQLITE_TESTCTRL_PRNG_RESTORE 6 +#define SQLITE_TESTCTRL_PRNG_RESET 7 +#define SQLITE_TESTCTRL_BITVEC_TEST 8 +#define SQLITE_TESTCTRL_FAULT_INSTALL 9 +#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 +#define SQLITE_TESTCTRL_PENDING_BYTE 11 +#define SQLITE_TESTCTRL_ASSERT 12 +#define SQLITE_TESTCTRL_ALWAYS 13 +#define SQLITE_TESTCTRL_RESERVE 14 +#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 +#define SQLITE_TESTCTRL_ISKEYWORD 16 +#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 +#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 +#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 +#define SQLITE_TESTCTRL_LAST 19 + +/* +** CAPI3REF: SQLite Runtime Status +** +** ^This interface is used to retrieve runtime status information +** about the performance of SQLite, and optionally to reset various +** highwater marks. ^The first argument is an integer code for +** the specific parameter to measure. ^(Recognized integer codes +** are of the form [status parameters | SQLITE_STATUS_...].)^ +** ^The current value of the parameter is returned into *pCurrent. +** ^The highest recorded value is returned in *pHighwater. ^If the +** resetFlag is true, then the highest record value is reset after +** *pHighwater is written. ^(Some parameters do not record the highest +** value. For those parameters +** nothing is written into *pHighwater and the resetFlag is ignored.)^ +** ^(Other parameters record only the highwater mark and not the current +** value. For these latter parameters nothing is written into *pCurrent.)^ +** +** ^The sqlite3_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** This routine is threadsafe but is not atomic. This routine can be +** called while other threads are running the same or different SQLite +** interfaces. However the values returned in *pCurrent and +** *pHighwater reflect the status of SQLite at different points in time +** and it is possible that another thread might change the parameter +** in between the times when *pCurrent and *pHighwater are written. +** +** See also: [sqlite3_db_status()] +*/ +SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); + + +/* +** CAPI3REF: Status Parameters +** KEYWORDS: {status parameters} +** +** These integer constants designate various run-time status parameters +** that can be returned by [sqlite3_status()]. +** +**
+** [[SQLITE_STATUS_MEMORY_USED]] ^(
SQLITE_STATUS_MEMORY_USED
+**
This parameter is the current amount of memory checked out +** using [sqlite3_malloc()], either directly or indirectly. The +** figure includes calls made to [sqlite3_malloc()] by the application +** and internal memory usage by the SQLite library. Scratch memory +** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache +** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in +** this parameter. The amount returned is the sum of the allocation +** sizes as reported by the xSize method in [sqlite3_mem_methods].
)^ +** +** [[SQLITE_STATUS_MALLOC_SIZE]] ^(
SQLITE_STATUS_MALLOC_SIZE
+**
This parameter records the largest memory allocation request +** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their +** internal equivalents). Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_MALLOC_COUNT]] ^(
SQLITE_STATUS_MALLOC_COUNT
+**
This parameter records the number of separate memory allocations +** currently checked out.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_USED]] ^(
SQLITE_STATUS_PAGECACHE_USED
+**
This parameter returns the number of pages used out of the +** [pagecache memory allocator] that was configured using +** [SQLITE_CONFIG_PAGECACHE]. The +** value returned is in pages, not in bytes.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]] +** ^(
SQLITE_STATUS_PAGECACHE_OVERFLOW
+**
This parameter returns the number of bytes of page cache +** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE] +** buffer and where forced to overflow to [sqlite3_malloc()]. The +** returned value includes allocations that overflowed because they +** where too large (they were larger than the "sz" parameter to +** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because +** no space was left in the page cache.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(
SQLITE_STATUS_PAGECACHE_SIZE
+**
This parameter records the largest memory allocation request +** handed to [pagecache memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_SCRATCH_USED]] ^(
SQLITE_STATUS_SCRATCH_USED
+**
This parameter returns the number of allocations used out of the +** [scratch memory allocator] configured using +** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not +** in bytes. Since a single thread may only have one scratch allocation +** outstanding at time, this parameter also reports the number of threads +** using scratch memory at the same time.
)^ +** +** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
+**
This parameter returns the number of bytes of scratch memory +** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH] +** buffer and where forced to overflow to [sqlite3_malloc()]. The values +** returned include overflows because the requested allocation was too +** larger (that is, because the requested allocation was larger than the +** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer +** slots were available. +**
)^ +** +** [[SQLITE_STATUS_SCRATCH_SIZE]] ^(
SQLITE_STATUS_SCRATCH_SIZE
+**
This parameter records the largest memory allocation request +** handed to [scratch memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_PARSER_STACK]] ^(
SQLITE_STATUS_PARSER_STACK
+**
This parameter records the deepest parser stack. It is only +** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
)^ +**
+** +** New status parameters may be added from time to time. +*/ +#define SQLITE_STATUS_MEMORY_USED 0 +#define SQLITE_STATUS_PAGECACHE_USED 1 +#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 +#define SQLITE_STATUS_SCRATCH_USED 3 +#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 +#define SQLITE_STATUS_MALLOC_SIZE 5 +#define SQLITE_STATUS_PARSER_STACK 6 +#define SQLITE_STATUS_PAGECACHE_SIZE 7 +#define SQLITE_STATUS_SCRATCH_SIZE 8 +#define SQLITE_STATUS_MALLOC_COUNT 9 + +/* +** CAPI3REF: Database Connection Status +** +** ^This interface is used to retrieve runtime status information +** about a single [database connection]. ^The first argument is the +** database connection object to be interrogated. ^The second argument +** is an integer constant, taken from the set of +** [SQLITE_DBSTATUS options], that +** determines the parameter to interrogate. The set of +** [SQLITE_DBSTATUS options] is likely +** to grow in future releases of SQLite. +** +** ^The current value of the requested parameter is written into *pCur +** and the highest instantaneous value is written into *pHiwtr. ^If +** the resetFlg is true, then the highest instantaneous value is +** reset back down to the current value. +** +** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. +*/ +SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); + +/* +** CAPI3REF: Status Parameters for database connections +** KEYWORDS: {SQLITE_DBSTATUS options} +** +** These constants are the available integer "verbs" that can be passed as +** the second argument to the [sqlite3_db_status()] interface. +** +** New verbs may be added in future releases of SQLite. Existing verbs +** might be discontinued. Applications should check the return code from +** [sqlite3_db_status()] to make sure that the call worked. +** The [sqlite3_db_status()] interface will return a non-zero error code +** if a discontinued or unsupported verb is invoked. +** +**
+** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(
SQLITE_DBSTATUS_LOOKASIDE_USED
+**
This parameter returns the number of lookaside memory slots currently +** checked out.
)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(
SQLITE_DBSTATUS_LOOKASIDE_HIT
+**
This parameter returns the number malloc attempts that were +** satisfied using lookaside memory. Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to the amount of +** memory requested being larger than the lookaside slot size. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to all lookaside +** memory already being in use. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_CACHE_USED]] ^(
SQLITE_DBSTATUS_CACHE_USED
+**
This parameter returns the approximate number of of bytes of heap +** memory used by all pager caches associated with the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0. +** +** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(
SQLITE_DBSTATUS_SCHEMA_USED
+**
This parameter returns the approximate number of of bytes of heap +** memory used to store the schema for all databases associated +** with the connection - main, temp, and any [ATTACH]-ed databases.)^ +** ^The full amount of memory used by the schemas is reported, even if the +** schema memory is shared with other database connections due to +** [shared cache mode] being enabled. +** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0. +** +** [[SQLITE_DBSTATUS_STMT_USED]] ^(
SQLITE_DBSTATUS_STMT_USED
+**
This parameter returns the approximate number of of bytes of heap +** and lookaside memory used by all prepared statements associated with +** the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(
SQLITE_DBSTATUS_CACHE_HIT
+**
This parameter returns the number of pager cache hits that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(
SQLITE_DBSTATUS_CACHE_MISS
+**
This parameter returns the number of pager cache misses that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(
SQLITE_DBSTATUS_CACHE_WRITE
+**
This parameter returns the number of dirty cache entries that have +** been written to disk. Specifically, the number of pages written to the +** wal file in wal mode databases, or the number of pages written to the +** database file in rollback mode databases. Any pages written as part of +** transaction rollback or database recovery operations are not included. +** If an IO or other error occurs while writing a page to disk, the effect +** on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The +** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0. +**
+**
+*/ +#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 +#define SQLITE_DBSTATUS_CACHE_USED 1 +#define SQLITE_DBSTATUS_SCHEMA_USED 2 +#define SQLITE_DBSTATUS_STMT_USED 3 +#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6 +#define SQLITE_DBSTATUS_CACHE_HIT 7 +#define SQLITE_DBSTATUS_CACHE_MISS 8 +#define SQLITE_DBSTATUS_CACHE_WRITE 9 +#define SQLITE_DBSTATUS_MAX 9 /* Largest defined DBSTATUS */ + + +/* +** CAPI3REF: Prepared Statement Status +** +** ^(Each prepared statement maintains various +** [SQLITE_STMTSTATUS counters] that measure the number +** of times it has performed specific operations.)^ These counters can +** be used to monitor the performance characteristics of the prepared +** statements. For example, if the number of table steps greatly exceeds +** the number of table searches or result rows, that would tend to indicate +** that the prepared statement is using a full table scan rather than +** an index. +** +** ^(This interface is used to retrieve and reset counter values from +** a [prepared statement]. The first argument is the prepared statement +** object to be interrogated. The second argument +** is an integer code for a specific [SQLITE_STMTSTATUS counter] +** to be interrogated.)^ +** ^The current value of the requested counter is returned. +** ^If the resetFlg is true, then the counter is reset to zero after this +** interface call returns. +** +** See also: [sqlite3_status()] and [sqlite3_db_status()]. +*/ +SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); + +/* +** CAPI3REF: Status Parameters for prepared statements +** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters} +** +** These preprocessor macros define integer codes that name counter +** values associated with the [sqlite3_stmt_status()] interface. +** The meanings of the various counters are as follows: +** +**
+** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]]
SQLITE_STMTSTATUS_FULLSCAN_STEP
+**
^This is the number of times that SQLite has stepped forward in +** a table as part of a full table scan. Large numbers for this counter +** may indicate opportunities for performance improvement through +** careful use of indices.
+** +** [[SQLITE_STMTSTATUS_SORT]]
SQLITE_STMTSTATUS_SORT
+**
^This is the number of sort operations that have occurred. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance through careful use of indices.
+** +** [[SQLITE_STMTSTATUS_AUTOINDEX]]
SQLITE_STMTSTATUS_AUTOINDEX
+**
^This is the number of rows inserted into transient indices that +** were created automatically in order to help joins run faster. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance by adding permanent indices that do not +** need to be reinitialized each time the statement is run.
+**
+*/ +#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 +#define SQLITE_STMTSTATUS_SORT 2 +#define SQLITE_STMTSTATUS_AUTOINDEX 3 + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache type is opaque. It is implemented by +** the pluggable module. The SQLite core has no knowledge of +** its size or internal structure and never deals with the +** sqlite3_pcache object except by holding and passing pointers +** to the object. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache sqlite3_pcache; + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache_page object represents a single page in the +** page cache. The page cache will allocate instances of this +** object. Various methods of the page cache use pointers to instances +** of this object as parameters or as their return value. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache_page sqlite3_pcache_page; +struct sqlite3_pcache_page { + void *pBuf; /* The content of the page */ + void *pExtra; /* Extra information associated with the page */ +}; + +/* +** CAPI3REF: Application Defined Page Cache. +** KEYWORDS: {page cache} +** +** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +** register an alternative page cache implementation by passing in an +** instance of the sqlite3_pcache_methods2 structure.)^ +** In many applications, most of the heap memory allocated by +** SQLite is used for the page cache. +** By implementing a +** custom page cache using this API, an application can better control +** the amount of memory consumed by SQLite, the way in which +** that memory is allocated and released, and the policies used to +** determine exactly which parts of a database file are cached and for +** how long. +** +** The alternative page cache mechanism is an +** extreme measure that is only needed by the most demanding applications. +** The built-in page cache is recommended for most uses. +** +** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +** internal buffer by SQLite within the call to [sqlite3_config]. Hence +** the application may discard the parameter after the call to +** [sqlite3_config()] returns.)^ +** +** [[the xInit() page cache method]] +** ^(The xInit() method is called once for each effective +** call to [sqlite3_initialize()])^ +** (usually only once during the lifetime of the process). ^(The xInit() +** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +** The intent of the xInit() method is to set up global data structures +** required by the custom page cache implementation. +** ^(If the xInit() method is NULL, then the +** built-in default page cache is used instead of the application defined +** page cache.)^ +** +** [[the xShutdown() page cache method]] +** ^The xShutdown() method is called by [sqlite3_shutdown()]. +** It can be used to clean up +** any outstanding resources before process shutdown, if required. +** ^The xShutdown() method may be NULL. +** +** ^SQLite automatically serializes calls to the xInit method, +** so the xInit method need not be threadsafe. ^The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. All other methods must be threadsafe +** in multithreaded applications. +** +** ^SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +** +** [[the xCreate() page cache methods]] +** ^SQLite invokes the xCreate() method to construct a new cache instance. +** SQLite will typically create one cache instance for each open database file, +** though this is not guaranteed. ^The +** first parameter, szPage, is the size in bytes of the pages that must +** be allocated by the cache. ^szPage will always a power of two. ^The +** second parameter szExtra is a number of bytes of extra storage +** associated with each page cache entry. ^The szExtra parameter will +** a number less than 250. SQLite will use the +** extra szExtra bytes on each page to store metadata about the underlying +** database page on disk. The value passed into szExtra depends +** on the SQLite version, the target platform, and how SQLite was compiled. +** ^The third argument to xCreate(), bPurgeable, is true if the cache being +** created will be used to cache database pages of a file stored on disk, or +** false if it is used for an in-memory database. The cache implementation +** does not have to do anything special based with the value of bPurgeable; +** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +** never invoke xUnpin() except to deliberately delete a page. +** ^In other words, calls to xUnpin() on a cache with bPurgeable set to +** false will always have the "discard" flag set to true. +** ^Hence, a cache created with bPurgeable false will +** never contain any unpinned pages. +** +** [[the xCachesize() page cache method]] +** ^(The xCachesize() method may be called at any time by SQLite to set the +** suggested maximum cache-size (number of pages stored by) the cache +** instance passed as the first argument. This is the value configured using +** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +** parameter, the implementation is not required to do anything with this +** value; it is advisory only. +** +** [[the xPagecount() page cache methods]] +** The xPagecount() method must return the number of pages currently +** stored in the cache, both pinned and unpinned. +** +** [[the xFetch() page cache methods]] +** The xFetch() method locates a page in the cache and returns a pointer to +** an sqlite3_pcache_page object associated with that page, or a NULL pointer. +** The pBuf element of the returned sqlite3_pcache_page object will be a +** pointer to a buffer of szPage bytes used to store the content of a +** single database page. The pExtra element of sqlite3_pcache_page will be +** a pointer to the szExtra bytes of extra storage that SQLite has requested +** for each entry in the page cache. +** +** The page to be fetched is determined by the key. ^The minimum key value +** is 1. After it has been retrieved using xFetch, the page is considered +** to be "pinned". +** +** If the requested page is already in the page cache, then the page cache +** implementation must return a pointer to the page buffer with its content +** intact. If the requested page is not already in the cache, then the +** cache implementation should use the value of the createFlag +** parameter to help it determined what action to take: +** +** +**
createFlag Behavior when page is not already in cache +**
0 Do not allocate a new page. Return NULL. +**
1 Allocate a new page if it easy and convenient to do so. +** Otherwise return NULL. +**
2 Make every effort to allocate a new page. Only return +** NULL if allocating a new page is effectively impossible. +**
+** +** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +** will only use a createFlag of 2 after a prior call with a createFlag of 1 +** failed.)^ In between the to xFetch() calls, SQLite may +** attempt to unpin one or more cache pages by spilling the content of +** pinned pages to disk and synching the operating system disk cache. +** +** [[the xUnpin() page cache method]] +** ^xUnpin() is called by SQLite with a pointer to a currently pinned page +** as its second argument. If the third parameter, discard, is non-zero, +** then the page must be evicted from the cache. +** ^If the discard parameter is +** zero, then the page may be discarded or retained at the discretion of +** page cache implementation. ^The page cache implementation +** may choose to evict unpinned pages at any time. +** +** The cache must not perform any reference counting. A single +** call to xUnpin() unpins the page regardless of the number of prior calls +** to xFetch(). +** +** [[the xRekey() page cache methods]] +** The xRekey() method is used to change the key value associated with the +** page passed as the second argument. If the cache +** previously contains an entry associated with newKey, it must be +** discarded. ^Any prior cache entry associated with newKey is guaranteed not +** to be pinned. +** +** When SQLite calls the xTruncate() method, the cache must discard all +** existing cache entries with page numbers (keys) greater than or equal +** to the value of the iLimit parameter passed to xTruncate(). If any +** of these pages are pinned, they are implicitly unpinned, meaning that +** they can be safely discarded. +** +** [[the xDestroy() page cache method]] +** ^The xDestroy() method is used to delete a cache allocated by xCreate(). +** All resources associated with the specified cache should be freed. ^After +** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +** handle invalid, and will not use it with any other sqlite3_pcache_methods2 +** functions. +** +** [[the xShrink() page cache method]] +** ^SQLite invokes the xShrink() method when it wants the page cache to +** free up as much of heap memory as possible. The page cache implementation +** is not obligated to free any memory, but well-behaved implementations should +** do their best. +*/ +typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2; +struct sqlite3_pcache_methods2 { + int iVersion; + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard); + void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*, + unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); + void (*xShrink)(sqlite3_pcache*); +}; + +/* +** This is the obsolete pcache_methods object that has now been replaced +** by sqlite3_pcache_methods2. This object is not used by SQLite. It is +** retained in the header file for backwards compatibility only. +*/ +typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; +struct sqlite3_pcache_methods { + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, void*, int discard); + void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); +}; + + +/* +** CAPI3REF: Online Backup Object +** +** The sqlite3_backup object records state information about an ongoing +** online backup operation. ^The sqlite3_backup object is created by +** a call to [sqlite3_backup_init()] and is destroyed by a call to +** [sqlite3_backup_finish()]. +** +** See Also: [Using the SQLite Online Backup API] +*/ +typedef struct sqlite3_backup sqlite3_backup; + +/* +** CAPI3REF: Online Backup API. +** +** The backup API copies the content of one database into another. +** It is useful either for creating backups of databases or +** for copying in-memory databases to or from persistent files. +** +** See Also: [Using the SQLite Online Backup API] +** +** ^SQLite holds a write transaction open on the destination database file +** for the duration of the backup operation. +** ^The source database is read-locked only while it is being read; +** it is not locked continuously for the entire backup operation. +** ^Thus, the backup may be performed on a live source database without +** preventing other database connections from +** reading or writing to the source database while the backup is underway. +** +** ^(To perform a backup operation: +**
    +**
  1. sqlite3_backup_init() is called once to initialize the +** backup, +**
  2. sqlite3_backup_step() is called one or more times to transfer +** the data between the two databases, and finally +**
  3. sqlite3_backup_finish() is called to release all resources +** associated with the backup operation. +**
)^ +** There should be exactly one call to sqlite3_backup_finish() for each +** successful call to sqlite3_backup_init(). +** +** [[sqlite3_backup_init()]] sqlite3_backup_init() +** +** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the +** [database connection] associated with the destination database +** and the database name, respectively. +** ^The database name is "main" for the main database, "temp" for the +** temporary database, or the name specified after the AS keyword in +** an [ATTACH] statement for an attached database. +** ^The S and M arguments passed to +** sqlite3_backup_init(D,N,S,M) identify the [database connection] +** and database name of the source database, respectively. +** ^The source and destination [database connections] (parameters S and D) +** must be different or else sqlite3_backup_init(D,N,S,M) will fail with +** an error. +** +** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is +** returned and an error code and error message are stored in the +** destination [database connection] D. +** ^The error code and message for the failed call to sqlite3_backup_init() +** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or +** [sqlite3_errmsg16()] functions. +** ^A successful call to sqlite3_backup_init() returns a pointer to an +** [sqlite3_backup] object. +** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and +** sqlite3_backup_finish() functions to perform the specified backup +** operation. +** +** [[sqlite3_backup_step()]] sqlite3_backup_step() +** +** ^Function sqlite3_backup_step(B,N) will copy up to N pages between +** the source and destination databases specified by [sqlite3_backup] object B. +** ^If N is negative, all remaining source pages are copied. +** ^If sqlite3_backup_step(B,N) successfully copies N pages and there +** are still more pages to be copied, then the function returns [SQLITE_OK]. +** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages +** from source to destination, then it returns [SQLITE_DONE]. +** ^If an error occurs while running sqlite3_backup_step(B,N), +** then an [error code] is returned. ^As well as [SQLITE_OK] and +** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], +** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. +** +** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if +**
    +**
  1. the destination database was opened read-only, or +**
  2. the destination database is using write-ahead-log journaling +** and the destination and source page sizes differ, or +**
  3. the destination database is an in-memory database and the +** destination and source page sizes differ. +**
)^ +** +** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then +** the [sqlite3_busy_handler | busy-handler function] +** is invoked (if one is specified). ^If the +** busy-handler returns non-zero before the lock is available, then +** [SQLITE_BUSY] is returned to the caller. ^In this case the call to +** sqlite3_backup_step() can be retried later. ^If the source +** [database connection] +** is being used to write to the source database when sqlite3_backup_step() +** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this +** case the call to sqlite3_backup_step() can be retried later on. ^(If +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or +** [SQLITE_READONLY] is returned, then +** there is no point in retrying the call to sqlite3_backup_step(). These +** errors are considered fatal.)^ The application must accept +** that the backup operation has failed and pass the backup operation handle +** to the sqlite3_backup_finish() to release associated resources. +** +** ^The first call to sqlite3_backup_step() obtains an exclusive lock +** on the destination file. ^The exclusive lock is not released until either +** sqlite3_backup_finish() is called or the backup operation is complete +** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to +** sqlite3_backup_step() obtains a [shared lock] on the source database that +** lasts for the duration of the sqlite3_backup_step() call. +** ^Because the source database is not locked between calls to +** sqlite3_backup_step(), the source database may be modified mid-way +** through the backup process. ^If the source database is modified by an +** external process or via a database connection other than the one being +** used by the backup operation, then the backup will be automatically +** restarted by the next call to sqlite3_backup_step(). ^If the source +** database is modified by the using the same database connection as is used +** by the backup operation, then the backup database is automatically +** updated at the same time. +** +** [[sqlite3_backup_finish()]] sqlite3_backup_finish() +** +** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the +** application wishes to abandon the backup operation, the application +** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). +** ^The sqlite3_backup_finish() interfaces releases all +** resources associated with the [sqlite3_backup] object. +** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any +** active write-transaction on the destination database is rolled back. +** The [sqlite3_backup] object is invalid +** and may not be used following a call to sqlite3_backup_finish(). +** +** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no +** sqlite3_backup_step() errors occurred, regardless or whether or not +** sqlite3_backup_step() completed. +** ^If an out-of-memory condition or IO error occurred during any prior +** sqlite3_backup_step() call on the same [sqlite3_backup] object, then +** sqlite3_backup_finish() returns the corresponding [error code]. +** +** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() +** is not a permanent error and does not affect the return value of +** sqlite3_backup_finish(). +** +** [[sqlite3_backup__remaining()]] [[sqlite3_backup_pagecount()]] +** sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** +** ^Each call to sqlite3_backup_step() sets two values inside +** the [sqlite3_backup] object: the number of pages still to be backed +** up and the total number of pages in the source database file. +** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces +** retrieve these two values, respectively. +** +** ^The values returned by these functions are only updated by +** sqlite3_backup_step(). ^If the source database is modified during a backup +** operation, then the values are not updated to account for any extra +** pages that need to be updated or the size of the source database file +** changing. +** +** Concurrent Usage of Database Handles +** +** ^The source [database connection] may be used by the application for other +** purposes while a backup operation is underway or being initialized. +** ^If SQLite is compiled and configured to support threadsafe database +** connections, then the source database connection may be used concurrently +** from within other threads. +** +** However, the application must guarantee that the destination +** [database connection] is not passed to any other API (by any thread) after +** sqlite3_backup_init() is called and before the corresponding call to +** sqlite3_backup_finish(). SQLite does not currently check to see +** if the application incorrectly accesses the destination [database connection] +** and so no error code is reported, but the operations may malfunction +** nevertheless. Use of the destination database connection while a +** backup is in progress might also also cause a mutex deadlock. +** +** If running in [shared cache mode], the application must +** guarantee that the shared cache used by the destination database +** is not accessed while the backup is running. In practice this means +** that the application must guarantee that the disk file being +** backed up to is not accessed by any connection within the process, +** not just the specific connection that was passed to sqlite3_backup_init(). +** +** The [sqlite3_backup] object itself is partially threadsafe. Multiple +** threads may safely make multiple concurrent calls to sqlite3_backup_step(). +** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** APIs are not strictly speaking threadsafe. If they are invoked at the +** same time as another thread is invoking sqlite3_backup_step() it is +** possible that they return invalid values. +*/ +SQLITE_API sqlite3_backup *sqlite3_backup_init( + sqlite3 *pDest, /* Destination database handle */ + const char *zDestName, /* Destination database name */ + sqlite3 *pSource, /* Source database handle */ + const char *zSourceName /* Source database name */ +); +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage); +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p); + +/* +** CAPI3REF: Unlock Notification +** +** ^When running in shared-cache mode, a database operation may fail with +** an [SQLITE_LOCKED] error if the required locks on the shared-cache or +** individual tables within the shared-cache cannot be obtained. See +** [SQLite Shared-Cache Mode] for a description of shared-cache locking. +** ^This API may be used to register a callback that SQLite will invoke +** when the connection currently holding the required lock relinquishes it. +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. +** +** See Also: [Using the SQLite Unlock Notification Feature]. +** +** ^Shared-cache locks are released when a database connection concludes +** its current transaction, either by committing it or rolling it back. +** +** ^When a connection (known as the blocked connection) fails to obtain a +** shared-cache lock and SQLITE_LOCKED is returned to the caller, the +** identity of the database connection (the blocking connection) that +** has locked the required resource is stored internally. ^After an +** application receives an SQLITE_LOCKED error, it may call the +** sqlite3_unlock_notify() method with the blocked connection handle as +** the first argument to register for a callback that will be invoked +** when the blocking connections current transaction is concluded. ^The +** callback is invoked from within the [sqlite3_step] or [sqlite3_close] +** call that concludes the blocking connections transaction. +** +** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, +** there is a chance that the blocking connection will have already +** concluded its transaction by the time sqlite3_unlock_notify() is invoked. +** If this happens, then the specified callback is invoked immediately, +** from within the call to sqlite3_unlock_notify().)^ +** +** ^If the blocked connection is attempting to obtain a write-lock on a +** shared-cache table, and more than one other connection currently holds +** a read-lock on the same table, then SQLite arbitrarily selects one of +** the other connections to use as the blocking connection. +** +** ^(There may be at most one unlock-notify callback registered by a +** blocked connection. If sqlite3_unlock_notify() is called when the +** blocked connection already has a registered unlock-notify callback, +** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is +** called with a NULL pointer as its second argument, then any existing +** unlock-notify callback is canceled. ^The blocked connections +** unlock-notify callback may also be canceled by closing the blocked +** connection using [sqlite3_close()]. +** +** The unlock-notify callback is not reentrant. If an application invokes +** any sqlite3_xxx API functions from within an unlock-notify callback, a +** crash or deadlock may be the result. +** +** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always +** returns SQLITE_OK. +** +** Callback Invocation Details +** +** When an unlock-notify callback is registered, the application provides a +** single void* pointer that is passed to the callback when it is invoked. +** However, the signature of the callback function allows SQLite to pass +** it an array of void* context pointers. The first argument passed to +** an unlock-notify callback is a pointer to an array of void* pointers, +** and the second is the number of entries in the array. +** +** When a blocking connections transaction is concluded, there may be +** more than one blocked connection that has registered for an unlock-notify +** callback. ^If two or more such blocked connections have specified the +** same callback function, then instead of invoking the callback function +** multiple times, it is invoked once with the set of void* context pointers +** specified by the blocked connections bundled together into an array. +** This gives the application an opportunity to prioritize any actions +** related to the set of unblocked database connections. +** +** Deadlock Detection +** +** Assuming that after registering for an unlock-notify callback a +** database waits for the callback to be issued before taking any further +** action (a reasonable assumption), then using this API may cause the +** application to deadlock. For example, if connection X is waiting for +** connection Y's transaction to be concluded, and similarly connection +** Y is waiting on connection X's transaction, then neither connection +** will proceed and the system may remain deadlocked indefinitely. +** +** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock +** detection. ^If a given call to sqlite3_unlock_notify() would put the +** system in a deadlocked state, then SQLITE_LOCKED is returned and no +** unlock-notify callback is registered. The system is said to be in +** a deadlocked state if connection A has registered for an unlock-notify +** callback on the conclusion of connection B's transaction, and connection +** B has itself registered for an unlock-notify callback when connection +** A's transaction is concluded. ^Indirect deadlock is also detected, so +** the system is also considered to be deadlocked if connection B has +** registered for an unlock-notify callback on the conclusion of connection +** C's transaction, where connection C is waiting on connection A. ^Any +** number of levels of indirection are allowed. +** +** The "DROP TABLE" Exception +** +** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost +** always appropriate to call sqlite3_unlock_notify(). There is however, +** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, +** SQLite checks if there are any currently executing SELECT statements +** that belong to the same connection. If there are, SQLITE_LOCKED is +** returned. In this case there is no "blocking connection", so invoking +** sqlite3_unlock_notify() results in the unlock-notify callback being +** invoked immediately. If the application then re-attempts the "DROP TABLE" +** or "DROP INDEX" query, an infinite loop might be the result. +** +** One way around this problem is to check the extended error code returned +** by an sqlite3_step() call. ^(If there is a blocking connection, then the +** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in +** the special "DROP TABLE/INDEX" case, the extended error code is just +** SQLITE_LOCKED.)^ +*/ +SQLITE_API int sqlite3_unlock_notify( + sqlite3 *pBlocked, /* Waiting connection */ + void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ + void *pNotifyArg /* Argument to pass to xNotify */ +); + + +/* +** CAPI3REF: String Comparison +** +** ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications +** and extensions to compare the contents of two buffers containing UTF-8 +** strings in a case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int sqlite3_stricmp(const char *, const char *); +SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); + +/* +** CAPI3REF: Error Logging Interface +** +** ^The [sqlite3_log()] interface writes a message into the error log +** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. +** ^If logging is enabled, the zFormat string and subsequent arguments are +** used with [sqlite3_snprintf()] to generate the final output string. +** +** The sqlite3_log() interface is intended for use by extensions such as +** virtual tables, collating functions, and SQL functions. While there is +** nothing to prevent an application from calling sqlite3_log(), doing so +** is considered bad form. +** +** The zFormat string must not be NULL. +** +** To avoid deadlocks and other threading problems, the sqlite3_log() routine +** will not use dynamically allocated memory. The log message is stored in +** a fixed-length buffer on the stack. If the log message is longer than +** a few hundred characters, it will be truncated to the length of the +** buffer. +*/ +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); + +/* +** CAPI3REF: Write-Ahead Log Commit Hook +** +** ^The [sqlite3_wal_hook()] function is used to register a callback that +** will be invoked each time a database connection commits data to a +** [write-ahead log] (i.e. whenever a transaction is committed in +** [journal_mode | journal_mode=WAL mode]). +** +** ^The callback is invoked by SQLite after the commit has taken place and +** the associated write-lock on the database released, so the implementation +** may read, write or [checkpoint] the database as required. +** +** ^The first parameter passed to the callback function when it is invoked +** is a copy of the third parameter passed to sqlite3_wal_hook() when +** registering the callback. ^The second is a copy of the database handle. +** ^The third parameter is the name of the database that was written to - +** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter +** is the number of pages currently in the write-ahead log file, +** including those that were just committed. +** +** The callback function should normally return [SQLITE_OK]. ^If an error +** code is returned, that error will propagate back up through the +** SQLite code base to cause the statement that provoked the callback +** to report an error, though the commit will have still occurred. If the +** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value +** that does not correspond to any valid SQLite error code, the results +** are undefined. +** +** A single database handle may have at most a single write-ahead log callback +** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any +** previously registered write-ahead log callback. ^Note that the +** [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will +** those overwrite any prior [sqlite3_wal_hook()] settings. +*/ +SQLITE_API void *sqlite3_wal_hook( + sqlite3*, + int(*)(void *,sqlite3*,const char*,int), + void* +); + +/* +** CAPI3REF: Configure an auto-checkpoint +** +** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around +** [sqlite3_wal_hook()] that causes any database on [database connection] D +** to automatically [checkpoint] +** after committing a transaction if there are N or +** more frames in the [write-ahead log] file. ^Passing zero or +** a negative value as the nFrame parameter disables automatic +** checkpoints entirely. +** +** ^The callback registered by this function replaces any existing callback +** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback +** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism +** configured by this function. +** +** ^The [wal_autocheckpoint pragma] can be used to invoke this interface +** from SQL. +** +** ^Every new [database connection] defaults to having the auto-checkpoint +** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT] +** pages. The use of this interface +** is only necessary if the default setting is found to be suboptimal +** for a particular application. +*/ +SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N); + +/* +** CAPI3REF: Checkpoint a database +** +** ^The [sqlite3_wal_checkpoint(D,X)] interface causes database named X +** on [database connection] D to be [checkpointed]. ^If X is NULL or an +** empty string, then a checkpoint is run on all databases of +** connection D. ^If the database connection D is not in +** [WAL | write-ahead log mode] then this interface is a harmless no-op. +** +** ^The [wal_checkpoint pragma] can be used to invoke this interface +** from SQL. ^The [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] can be used to cause this interface to be +** run whenever the WAL reaches a certain size threshold. +** +** See also: [sqlite3_wal_checkpoint_v2()] +*/ +SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Checkpoint a database +** +** Run a checkpoint operation on WAL database zDb attached to database +** handle db. The specific operation is determined by the value of the +** eMode parameter: +** +**
+**
SQLITE_CHECKPOINT_PASSIVE
+** Checkpoint as many frames as possible without waiting for any database +** readers or writers to finish. Sync the db file if all frames in the log +** are checkpointed. This mode is the same as calling +** sqlite3_wal_checkpoint(). The busy-handler callback is never invoked. +** +**
SQLITE_CHECKPOINT_FULL
+** This mode blocks (calls the busy-handler callback) until there is no +** database writer and all readers are reading from the most recent database +** snapshot. It then checkpoints all frames in the log file and syncs the +** database file. This call blocks database writers while it is running, +** but not database readers. +** +**
SQLITE_CHECKPOINT_RESTART
+** This mode works the same way as SQLITE_CHECKPOINT_FULL, except after +** checkpointing the log file it blocks (calls the busy-handler callback) +** until all readers are reading from the database file only. This ensures +** that the next client to write to the database file restarts the log file +** from the beginning. This call blocks database writers while it is running, +** but not database readers. +**
+** +** If pnLog is not NULL, then *pnLog is set to the total number of frames in +** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to +** the total number of checkpointed frames (including any that were already +** checkpointed when this function is called). *pnLog and *pnCkpt may be +** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK. +** If no values are available because of an error, they are both set to -1 +** before returning to communicate this to the caller. +** +** All calls obtain an exclusive "checkpoint" lock on the database file. If +** any other process is running a checkpoint operation at the same time, the +** lock cannot be obtained and SQLITE_BUSY is returned. Even if there is a +** busy-handler configured, it will not be invoked in this case. +** +** The SQLITE_CHECKPOINT_FULL and RESTART modes also obtain the exclusive +** "writer" lock on the database file. If the writer lock cannot be obtained +** immediately, and a busy-handler is configured, it is invoked and the writer +** lock retried until either the busy-handler returns 0 or the lock is +** successfully obtained. The busy-handler is also invoked while waiting for +** database readers as described above. If the busy-handler returns 0 before +** the writer lock is obtained or while waiting for database readers, the +** checkpoint operation proceeds from that point in the same way as +** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible +** without blocking any further. SQLITE_BUSY is returned in this case. +** +** If parameter zDb is NULL or points to a zero length string, then the +** specified operation is attempted on all WAL databases. In this case the +** values written to output parameters *pnLog and *pnCkpt are undefined. If +** an SQLITE_BUSY error is encountered when processing one or more of the +** attached WAL databases, the operation is still attempted on any remaining +** attached databases and SQLITE_BUSY is returned to the caller. If any other +** error occurs while processing an attached database, processing is abandoned +** and the error code returned to the caller immediately. If no error +** (SQLITE_BUSY or otherwise) is encountered while processing the attached +** databases, SQLITE_OK is returned. +** +** If database zDb is the name of an attached database that is not in WAL +** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If +** zDb is not NULL (or a zero length string) and is not the name of any +** attached database, SQLITE_ERROR is returned to the caller. +*/ +SQLITE_API int sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +); + +/* +** CAPI3REF: Checkpoint operation parameters +** +** These constants can be used as the 3rd parameter to +** [sqlite3_wal_checkpoint_v2()]. See the [sqlite3_wal_checkpoint_v2()] +** documentation for additional information about the meaning and use of +** each of these values. +*/ +#define SQLITE_CHECKPOINT_PASSIVE 0 +#define SQLITE_CHECKPOINT_FULL 1 +#define SQLITE_CHECKPOINT_RESTART 2 + +/* +** CAPI3REF: Virtual Table Interface Configuration +** +** This function may be called by either the [xConnect] or [xCreate] method +** of a [virtual table] implementation to configure +** various facets of the virtual table interface. +** +** If this interface is invoked outside the context of an xConnect or +** xCreate virtual table method then the behavior is undefined. +** +** At present, there is only one option that may be configured using +** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].) Further options +** may be added in the future. +*/ +SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Virtual Table Configuration Options +** +** These macros define the various options to the +** [sqlite3_vtab_config()] interface that [virtual table] implementations +** can use to customize and optimize their behavior. +** +**
+**
SQLITE_VTAB_CONSTRAINT_SUPPORT +**
Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported, +** where X is an integer. If X is zero, then the [virtual table] whose +** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not +** support constraints. In this configuration (which is the default) if +** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire +** statement is rolled back as if [ON CONFLICT | OR ABORT] had been +** specified as part of the users SQL statement, regardless of the actual +** ON CONFLICT mode specified. +** +** If X is non-zero, then the virtual table implementation guarantees +** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before +** any modifications to internal or persistent data structures have been made. +** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite +** is able to roll back a statement or database transaction, and abandon +** or continue processing the current SQL statement as appropriate. +** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns +** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode +** had been ABORT. +** +** Virtual table implementations that are required to handle OR REPLACE +** must do so within the [xUpdate] method. If a call to the +** [sqlite3_vtab_on_conflict()] function indicates that the current ON +** CONFLICT policy is REPLACE, the virtual table implementation should +** silently replace the appropriate rows within the xUpdate callback and +** return SQLITE_OK. Or, if this is not possible, it may return +** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT +** constraint handling. +**
+*/ +#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1 + +/* +** CAPI3REF: Determine The Virtual Table Conflict Policy +** +** This function may only be called from within a call to the [xUpdate] method +** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The +** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL], +** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode +** of the SQL statement that triggered the call to the [xUpdate] method of the +** [virtual table]. +*/ +SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *); + +/* +** CAPI3REF: Conflict resolution modes +** +** These constants are returned by [sqlite3_vtab_on_conflict()] to +** inform a [virtual table] implementation what the [ON CONFLICT] mode +** is for the SQL statement being evaluated. +** +** Note that the [SQLITE_IGNORE] constant is also used as a potential +** return value from the [sqlite3_set_authorizer()] callback and that +** [SQLITE_ABORT] is also a [result code]. +*/ +#define SQLITE_ROLLBACK 1 +/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */ +#define SQLITE_FAIL 3 +/* #define SQLITE_ABORT 4 // Also an error code */ +#define SQLITE_REPLACE 5 + + + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#ifdef __cplusplus +} /* End of the 'extern "C"' block */ +#endif +#endif + +/* +** 2010 August 30 +** +** 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. +** +************************************************************************* +*/ + +#ifndef _SQLITE3RTREE_H_ +#define _SQLITE3RTREE_H_ + + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry; + +/* +** Register a geometry callback named zGeom that can be used as part of an +** R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zGeom(... params ...) +*/ +SQLITE_API int sqlite3_rtree_geometry_callback( + sqlite3 *db, + const char *zGeom, +#ifdef SQLITE_RTREE_INT_ONLY + int (*xGeom)(sqlite3_rtree_geometry*, int n, sqlite3_int64 *a, int *pRes), +#else + int (*xGeom)(sqlite3_rtree_geometry*, int n, double *a, int *pRes), +#endif + void *pContext +); + + +/* +** A pointer to a structure of the following type is passed as the first +** argument to callbacks registered using rtree_geometry_callback(). +*/ +struct sqlite3_rtree_geometry { + void *pContext; /* Copy of pContext passed to s_r_g_c() */ + int nParam; /* Size of array aParam[] */ + double *aParam; /* Parameters passed to SQL geom function */ + void *pUser; /* Callback implementation user data */ + void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */ +}; + + +#ifdef __cplusplus +} /* end of the 'extern "C"' block */ +#endif + +#endif /* ifndef _SQLITE3RTREE_H_ */ + diff --git a/smart_home_server/include/tcp.h b/smart_home_server/include/tcp.h new file mode 100755 index 0000000..e9c8b79 --- /dev/null +++ b/smart_home_server/include/tcp.h @@ -0,0 +1,21 @@ +#ifndef __TCP_H__ +#define __TCP_H__ + +int tcp_server_init(const char *ip, const char *port); +int tcp_server_wait_connect(int listenfd); +ssize_t tcp_server_recv(int connfd, void *buf, size_t count); +ssize_t tcp_server_send(int connfd, const void *buf, size_t count); +ssize_t tcp_server_recv_exact_nbytes(int connfd, void *buf, size_t count); +ssize_t tcp_server_send_exact_nbytes(int connfd, const void *buf, size_t count); +int tcp_server_disconnect(int connfd); +int tcp_server_exit(int listenfd); + +int tcp_client_init(void); +int tcp_client_connect(int sockfd, const char *ip, const char *port); +ssize_t tcp_client_recv(int sockfd, void *buf, size_t count); +ssize_t tcp_client_send(int sockfd, const void *buf, size_t count); +ssize_t tcp_client_recv_exact_nbytes(int sockfd, void *buf, size_t count); +ssize_t tcp_client_send_exact_nbytes(int sockfd, const void *buf, size_t count); +int tcp_client_exit(int sockfd); + +#endif diff --git a/smart_home_server/main b/smart_home_server/main new file mode 100755 index 0000000000000000000000000000000000000000..641a8a9e81d019578c82bd1a0c146f65314bd13c GIT binary patch literal 799180 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 UeXnzYA=R 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
+** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
+** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
+** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
+**
)^ +** +** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION] +** macro. ^The sqlite3_libversion() function returns a pointer to the +** to the sqlite3_version[] string constant. The sqlite3_libversion() +** function is provided for use in DLLs since DLL users usually do not have +** direct access to string constants within the DLL. ^The +** sqlite3_libversion_number() function returns an integer equal to +** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns +** a pointer to a string constant whose value is the same as the +** [SQLITE_SOURCE_ID] C preprocessor macro. +** +** See also: [sqlite_version()] and [sqlite_source_id()]. +*/ +SQLITE_API const char sqlite3_version[] = SQLITE_VERSION; +SQLITE_API const char *sqlite3_libversion(void); +SQLITE_API const char *sqlite3_sourceid(void); +SQLITE_API int sqlite3_libversion_number(void); + +/* +** CAPI3REF: Run-Time Library Compilation Options Diagnostics +** +** ^The sqlite3_compileoption_used() function returns 0 or 1 +** indicating whether the specified option was defined at +** compile time. ^The SQLITE_ prefix may be omitted from the +** option name passed to sqlite3_compileoption_used(). +** +** ^The sqlite3_compileoption_get() function allows iterating +** over the list of options that were defined at compile time by +** returning the N-th compile time option string. ^If N is out of range, +** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ +** prefix is omitted from any strings returned by +** sqlite3_compileoption_get(). +** +** ^Support for the diagnostic functions sqlite3_compileoption_used() +** and sqlite3_compileoption_get() may be omitted by specifying the +** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. +** +** See also: SQL functions [sqlite_compileoption_used()] and +** [sqlite_compileoption_get()] and the [compile_options pragma]. +*/ +#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS +SQLITE_API int sqlite3_compileoption_used(const char *zOptName); +SQLITE_API const char *sqlite3_compileoption_get(int N); +#endif + +/* +** CAPI3REF: Test To See If The Library Is Threadsafe +** +** ^The sqlite3_threadsafe() function returns zero if and only if +** SQLite was compiled with mutexing code omitted due to the +** [SQLITE_THREADSAFE] compile-time option being set to 0. +** +** SQLite can be compiled with or without mutexes. When +** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes +** are enabled and SQLite is threadsafe. When the +** [SQLITE_THREADSAFE] macro is 0, +** the mutexes are omitted. Without the mutexes, it is not safe +** to use SQLite concurrently from more than one thread. +** +** Enabling mutexes incurs a measurable performance penalty. +** So if speed is of utmost importance, it makes sense to disable +** the mutexes. But for maximum safety, mutexes should be enabled. +** ^The default behavior is for mutexes to be enabled. +** +** This interface can be used by an application to make sure that the +** version of SQLite that it is linking against was compiled with +** the desired setting of the [SQLITE_THREADSAFE] macro. +** +** This interface only reports on the compile-time mutex setting +** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with +** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but +** can be fully or partially disabled using a call to [sqlite3_config()] +** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], +** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the +** sqlite3_threadsafe() function shows only the compile-time setting of +** thread safety, not any run-time changes to that setting made by +** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() +** is unchanged by calls to sqlite3_config().)^ +** +** See the [threading mode] documentation for additional information. +*/ +SQLITE_API int sqlite3_threadsafe(void); + +/* +** CAPI3REF: Database Connection Handle +** KEYWORDS: {database connection} {database connections} +** +** Each open SQLite database is represented by a pointer to an instance of +** the opaque structure named "sqlite3". It is useful to think of an sqlite3 +** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and +** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] +** and [sqlite3_close_v2()] are its destructors. There are many other +** interfaces (such as +** [sqlite3_prepare_v2()], [sqlite3_create_function()], and +** [sqlite3_busy_timeout()] to name but three) that are methods on an +** sqlite3 object. +*/ +typedef struct sqlite3 sqlite3; + +/* +** CAPI3REF: 64-Bit Integer Types +** KEYWORDS: sqlite_int64 sqlite_uint64 +** +** Because there is no cross-platform way to specify 64-bit integer types +** SQLite includes typedefs for 64-bit signed and unsigned integers. +** +** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. +** The sqlite_int64 and sqlite_uint64 types are supported for backwards +** compatibility only. +** +** ^The sqlite3_int64 and sqlite_int64 types can store integer values +** between -9223372036854775808 and +9223372036854775807 inclusive. ^The +** sqlite3_uint64 and sqlite_uint64 types can store integer values +** between 0 and +18446744073709551615 inclusive. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif +typedef sqlite_int64 sqlite3_int64; +typedef sqlite_uint64 sqlite3_uint64; + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite3_int64 +#endif + +/* +** CAPI3REF: Closing A Database Connection +** +** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors +** for the [sqlite3] object. +** ^Calls to sqlite3_close() and sqlite3_close_v2() return SQLITE_OK if +** the [sqlite3] object is successfully destroyed and all associated +** resources are deallocated. +** +** ^If the database connection is associated with unfinalized prepared +** statements or unfinished sqlite3_backup objects then sqlite3_close() +** will leave the database connection open and return [SQLITE_BUSY]. +** ^If sqlite3_close_v2() is called with unfinalized prepared statements +** and unfinished sqlite3_backups, then the database connection becomes +** an unusable "zombie" which will automatically be deallocated when the +** last prepared statement is finalized or the last sqlite3_backup is +** finished. The sqlite3_close_v2() interface is intended for use with +** host languages that are garbage collected, and where the order in which +** destructors are called is arbitrary. +** +** Applications should [sqlite3_finalize | finalize] all [prepared statements], +** [sqlite3_blob_close | close] all [BLOB handles], and +** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated +** with the [sqlite3] object prior to attempting to close the object. ^If +** sqlite3_close_v2() is called on a [database connection] that still has +** outstanding [prepared statements], [BLOB handles], and/or +** [sqlite3_backup] objects then it returns SQLITE_OK but the deallocation +** of resources is deferred until all [prepared statements], [BLOB handles], +** and [sqlite3_backup] objects are also destroyed. +** +** ^If an [sqlite3] object is destroyed while a transaction is open, +** the transaction is automatically rolled back. +** +** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)] +** must be either a NULL +** pointer or an [sqlite3] object pointer obtained +** from [sqlite3_open()], [sqlite3_open16()], or +** [sqlite3_open_v2()], and not previously closed. +** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer +** argument is a harmless no-op. +*/ +SQLITE_API int sqlite3_close(sqlite3*); +SQLITE_API int sqlite3_close_v2(sqlite3*); + +/* +** The type for a callback function. +** This is legacy and deprecated. It is included for historical +** compatibility and is not documented. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** CAPI3REF: One-Step Query Execution Interface +** +** The sqlite3_exec() interface is a convenience wrapper around +** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], +** that allows an application to run multiple statements of SQL +** without having to use a lot of C code. +** +** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, +** semicolon-separate SQL statements passed into its 2nd argument, +** in the context of the [database connection] passed in as its 1st +** argument. ^If the callback function of the 3rd argument to +** sqlite3_exec() is not NULL, then it is invoked for each result row +** coming out of the evaluated SQL statements. ^The 4th argument to +** sqlite3_exec() is relayed through to the 1st argument of each +** callback invocation. ^If the callback pointer to sqlite3_exec() +** is NULL, then no callback is ever invoked and result rows are +** ignored. +** +** ^If an error occurs while evaluating the SQL statements passed into +** sqlite3_exec(), then execution of the current statement stops and +** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() +** is not NULL then any error message is written into memory obtained +** from [sqlite3_malloc()] and passed back through the 5th parameter. +** To avoid memory leaks, the application should invoke [sqlite3_free()] +** on error message strings returned through the 5th parameter of +** of sqlite3_exec() after the error message string is no longer needed. +** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors +** occur, then sqlite3_exec() sets the pointer in its 5th parameter to +** NULL before returning. +** +** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() +** routine returns SQLITE_ABORT without invoking the callback again and +** without running any subsequent SQL statements. +** +** ^The 2nd argument to the sqlite3_exec() callback function is the +** number of columns in the result. ^The 3rd argument to the sqlite3_exec() +** callback is an array of pointers to strings obtained as if from +** [sqlite3_column_text()], one for each column. ^If an element of a +** result row is NULL then the corresponding string pointer for the +** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the +** sqlite3_exec() callback is an array of pointers to strings where each +** entry represents the name of corresponding result column as obtained +** from [sqlite3_column_name()]. +** +** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer +** to an empty string, or a pointer that contains only whitespace and/or +** SQL comments, then no SQL statements are evaluated and the database +** is not changed. +** +** Restrictions: +** +**
    +**
  • The application must insure that the 1st parameter to sqlite3_exec() +** is a valid and open [database connection]. +**
  • The application must not close [database connection] specified by +** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. +**
  • The application must not modify the SQL statement text passed into +** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. +**
+*/ +SQLITE_API int sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be evaluated */ + int (*callback)(void*,int,char**,char**), /* Callback function */ + void *, /* 1st argument to callback */ + char **errmsg /* Error msg written here */ +); + +/* +** CAPI3REF: Result Codes +** KEYWORDS: SQLITE_OK {error code} {error codes} +** KEYWORDS: {result code} {result codes} +** +** Many SQLite functions return an integer result code from the set shown +** here in order to indicate success or failure. +** +** New error codes may be added in future versions of SQLite. +** +** See also: [SQLITE_IOERR_READ | extended result codes], +** [sqlite3_vtab_on_conflict()] [SQLITE_ROLLBACK | result codes]. +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ +#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** CAPI3REF: Extended Result Codes +** KEYWORDS: {extended error code} {extended error codes} +** KEYWORDS: {extended result code} {extended result codes} +** +** In its default configuration, SQLite API routines return one of 26 integer +** [SQLITE_OK | result codes]. However, experience has shown that many of +** these result codes are too coarse-grained. They do not provide as +** much information about problems as programmers might like. In an effort to +** address this, newer versions of SQLite (version 3.3.8 and later) include +** support for additional result codes that provide more detailed information +** about errors. The extended result codes are enabled or disabled +** on a per database connection basis using the +** [sqlite3_extended_result_codes()] API. +** +** Some of the available extended result codes are listed here. +** One may expect the number of extended result codes will be expand +** over time. Software that uses extended result codes should expect +** to see new result codes in future releases of SQLite. +** +** The SQLITE_OK result code will never be extended. It will always +** be exactly zero. +*/ +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) +#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) +#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) +#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) +#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) +#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) +#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) +#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) +#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) +#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) +#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) +#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) +#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) +#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) +#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) +#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) +#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) +#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) +#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) +#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) +#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) +#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) +#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) +#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) +#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) +#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) +#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) +#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) +#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) +#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) +#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) +#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) +#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) +#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) + +/* +** CAPI3REF: Flags For File Open Operations +** +** These bit values are intended for use in the +** 3rd parameter to the [sqlite3_open_v2()] interface and +** in the 4th parameter to the [sqlite3_vfs.xOpen] method. +*/ +#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ +#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ +#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ +#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ +#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ +#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ +#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ +#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ +#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ +#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ +#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ +#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ + +/* Reserved: 0x00F00000 */ + +/* +** CAPI3REF: Device Characteristics +** +** The xDeviceCharacteristics method of the [sqlite3_io_methods] +** object returns an integer which is a vector of these +** bit values expressing I/O characteristics of the mass storage +** device that holds the file that the [sqlite3_io_methods] +** refers to. +** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +** after reboot following a crash or power loss, the only bytes in a +** file that were written at the application level might have changed +** and that adjacent bytes, even bytes within the same sector are +** guaranteed to be unchanged. +*/ +#define SQLITE_IOCAP_ATOMIC 0x00000001 +#define SQLITE_IOCAP_ATOMIC512 0x00000002 +#define SQLITE_IOCAP_ATOMIC1K 0x00000004 +#define SQLITE_IOCAP_ATOMIC2K 0x00000008 +#define SQLITE_IOCAP_ATOMIC4K 0x00000010 +#define SQLITE_IOCAP_ATOMIC8K 0x00000020 +#define SQLITE_IOCAP_ATOMIC16K 0x00000040 +#define SQLITE_IOCAP_ATOMIC32K 0x00000080 +#define SQLITE_IOCAP_ATOMIC64K 0x00000100 +#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 +#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 +#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 +#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 + +/* +** CAPI3REF: File Locking Levels +** +** SQLite uses one of these integer values as the second +** argument to calls it makes to the xLock() and xUnlock() methods +** of an [sqlite3_io_methods] object. +*/ +#define SQLITE_LOCK_NONE 0 +#define SQLITE_LOCK_SHARED 1 +#define SQLITE_LOCK_RESERVED 2 +#define SQLITE_LOCK_PENDING 3 +#define SQLITE_LOCK_EXCLUSIVE 4 + +/* +** CAPI3REF: Synchronization Type Flags +** +** When SQLite invokes the xSync() method of an +** [sqlite3_io_methods] object it uses a combination of +** these integer values as the second argument. +** +** When the SQLITE_SYNC_DATAONLY flag is used, it means that the +** sync operation only needs to flush data to mass storage. Inode +** information need not be flushed. If the lower four bits of the flag +** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. +** If the lower four bits equal SQLITE_SYNC_FULL, that means +** to use Mac OS X style fullsync instead of fsync(). +** +** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +** settings. The [synchronous pragma] determines when calls to the +** xSync VFS method occur and applies uniformly across all platforms. +** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +** energetic or rigorous or forceful the sync operations are and +** only make a difference on Mac OSX for the default SQLite code. +** (Third-party VFS implementations might also make the distinction +** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +** operating systems natively supported by SQLite, only Mac OSX +** cares about the difference.) +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + +/* +** CAPI3REF: OS Interface Open File Handle +** +** An [sqlite3_file] object represents an open file in the +** [sqlite3_vfs | OS interface layer]. Individual OS interface +** implementations will +** want to subclass this object by appending additional fields +** for their own use. The pMethods entry is a pointer to an +** [sqlite3_io_methods] object that defines methods for performing +** I/O operations on the open file. +*/ +typedef struct sqlite3_file sqlite3_file; +struct sqlite3_file { + const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ +}; + +/* +** CAPI3REF: OS Interface File Virtual Methods Object +** +** Every file opened by the [sqlite3_vfs.xOpen] method populates an +** [sqlite3_file] object (or, more commonly, a subclass of the +** [sqlite3_file] object) with a pointer to an instance of this object. +** This object defines the methods used to perform various operations +** against the open file represented by the [sqlite3_file] object. +** +** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element +** to a non-NULL pointer, then the sqlite3_io_methods.xClose method +** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The +** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] +** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element +** to NULL. +** +** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] +** flag may be ORed in to indicate that only the data of the file +** and not its inode needs to be synced. +** +** The integer values to xLock() and xUnlock() are one of +**
    +**
  • [SQLITE_LOCK_NONE], +**
  • [SQLITE_LOCK_SHARED], +**
  • [SQLITE_LOCK_RESERVED], +**
  • [SQLITE_LOCK_PENDING], or +**
  • [SQLITE_LOCK_EXCLUSIVE]. +**
+** xLock() increases the lock. xUnlock() decreases the lock. +** The xCheckReservedLock() method checks whether any database connection, +** either in this process or in some other process, is holding a RESERVED, +** PENDING, or EXCLUSIVE lock on the file. It returns true +** if such a lock exists and false otherwise. +** +** The xFileControl() method is a generic interface that allows custom +** VFS implementations to directly control an open file using the +** [sqlite3_file_control()] interface. The second "op" argument is an +** integer opcode. The third argument is a generic pointer intended to +** point to a structure that may contain arguments or space in which to +** write return values. Potential uses for xFileControl() might be +** functions to enable blocking locks with timeouts, to change the +** locking strategy (for example to use dot-file locks), to inquire +** about the status of a lock, or to break stale locks. The SQLite +** core reserves all opcodes less than 100 for its own use. +** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. VFS implementations should +** return [SQLITE_NOTFOUND] for file control opcodes that they do not +** recognize. +** +** The xSectorSize() method returns the sector size of the +** device that underlies the file. The sector size is the +** minimum write that can be performed without disturbing +** other bytes in the file. The xDeviceCharacteristics() +** method returns a bit vector describing behaviors of the +** underlying device: +** +**
    +**
  • [SQLITE_IOCAP_ATOMIC] +**
  • [SQLITE_IOCAP_ATOMIC512] +**
  • [SQLITE_IOCAP_ATOMIC1K] +**
  • [SQLITE_IOCAP_ATOMIC2K] +**
  • [SQLITE_IOCAP_ATOMIC4K] +**
  • [SQLITE_IOCAP_ATOMIC8K] +**
  • [SQLITE_IOCAP_ATOMIC16K] +**
  • [SQLITE_IOCAP_ATOMIC32K] +**
  • [SQLITE_IOCAP_ATOMIC64K] +**
  • [SQLITE_IOCAP_SAFE_APPEND] +**
  • [SQLITE_IOCAP_SEQUENTIAL] +**
+** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +** +** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill +** in the unread portions of the buffer with zeros. A VFS that +** fails to zero-fill short reads might seem to work. However, +** failure to zero-fill short reads will eventually lead to +** database corruption. +*/ +typedef struct sqlite3_io_methods sqlite3_io_methods; +struct sqlite3_io_methods { + int iVersion; + int (*xClose)(sqlite3_file*); + int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); + int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); + int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); + int (*xSync)(sqlite3_file*, int flags); + int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); + int (*xLock)(sqlite3_file*, int); + int (*xUnlock)(sqlite3_file*, int); + int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); + int (*xFileControl)(sqlite3_file*, int op, void *pArg); + int (*xSectorSize)(sqlite3_file*); + int (*xDeviceCharacteristics)(sqlite3_file*); + /* Methods above are valid for version 1 */ + int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**); + int (*xShmLock)(sqlite3_file*, int offset, int n, int flags); + void (*xShmBarrier)(sqlite3_file*); + int (*xShmUnmap)(sqlite3_file*, int deleteFlag); + /* Methods above are valid for version 2 */ + /* Additional methods may be added in future releases */ +}; + +/* +** CAPI3REF: Standard File Control Opcodes +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] +** interface. +** +** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This +** opcode causes the xFileControl method to write the current state of +** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], +** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) +** into an integer that the pArg argument points to. This capability +** is used during testing and only needs to be supported when SQLITE_TEST +** is defined. +**
    +**
  • [[SQLITE_FCNTL_SIZE_HINT]] +** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS +** layer a hint of how large the database file will grow to be during the +** current transaction. This hint is not guaranteed to be accurate but it +** is often close. The underlying VFS might choose to preallocate database +** file space based on this hint in order to help writes to the database +** file run faster. +** +**
  • [[SQLITE_FCNTL_CHUNK_SIZE]] +** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS +** extends and truncates the database file in chunks of a size specified +** by the user. The fourth argument to [sqlite3_file_control()] should +** point to an integer (type int) containing the new chunk-size to use +** for the nominated database. Allocating database file space in large +** chunks (say 1MB at a time), may reduce file-system fragmentation and +** improve performance on some systems. +** +**
  • [[SQLITE_FCNTL_FILE_POINTER]] +** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer +** to the [sqlite3_file] object associated with a particular database +** connection. See the [sqlite3_file_control()] documentation for +** additional information. +** +**
  • [[SQLITE_FCNTL_SYNC_OMITTED]] +** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by +** SQLite and sent to all VFSes in place of a call to the xSync method +** when the database connection has [PRAGMA synchronous] set to OFF.)^ +** Some specialized VFSes need this signal in order to operate correctly +** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most +** VFSes do not need this signal and should silently ignore this opcode. +** Applications should not call [sqlite3_file_control()] with this +** opcode as doing so may disrupt the operation of the specialized VFSes +** that do require it. +** +**
  • [[SQLITE_FCNTL_WIN32_AV_RETRY]] +** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic +** retry counts and intervals for certain disk I/O operations for the +** windows [VFS] in order to provide robustness in the presence of +** anti-virus programs. By default, the windows VFS will retry file read, +** file write, and file delete operations up to 10 times, with a delay +** of 25 milliseconds before the first retry and with the delay increasing +** by an additional 25 milliseconds with each subsequent retry. This +** opcode allows these two values (10 retries and 25 milliseconds of delay) +** to be adjusted. The values are changed for all database connections +** within the same process. The argument is a pointer to an array of two +** integers where the first integer i the new retry count and the second +** integer is the delay. If either integer is negative, then the setting +** is not changed but instead the prior value of that setting is written +** into the array entry, allowing the current retry settings to be +** interrogated. The zDbName parameter is ignored. +** +**
  • [[SQLITE_FCNTL_PERSIST_WAL]] +** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the +** persistent [WAL | Write Ahead Log] setting. By default, the auxiliary +** write ahead log and shared memory files used for transaction control +** are automatically deleted when the latest connection to the database +** closes. Setting persistent WAL mode causes those files to persist after +** close. Persisting the files is useful when other processes that do not +** have write permission on the directory containing the database file want +** to read the database file, as the WAL and shared memory files must exist +** in order for the database to be readable. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable persistent WAL mode or 1 to enable persistent +** WAL mode. If the integer is -1, then it is overwritten with the current +** WAL persistence setting. +** +**
  • [[SQLITE_FCNTL_POWERSAFE_OVERWRITE]] +** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the +** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting +** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the +** xDeviceCharacteristics methods. The fourth parameter to +** [sqlite3_file_control()] for this opcode should be a pointer to an integer. +** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage +** mode. If the integer is -1, then it is overwritten with the current +** zero-damage mode setting. +** +**
  • [[SQLITE_FCNTL_OVERWRITE]] +** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening +** a write transaction to indicate that, unless it is rolled back for some +** reason, the entire database file will be overwritten by the current +** transaction. This is used by VACUUM operations. +** +**
  • [[SQLITE_FCNTL_VFSNAME]] +** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of +** all [VFSes] in the VFS stack. The names are of all VFS shims and the +** final bottom-level VFS are written into memory obtained from +** [sqlite3_malloc()] and the result is stored in the char* variable +** that the fourth parameter of [sqlite3_file_control()] points to. +** The caller is responsible for freeing the memory when done. As with +** all file-control actions, there is no guarantee that this will actually +** do anything. Callers should initialize the char* variable to a NULL +** pointer in case this file-control is not implemented. This file-control +** is intended for diagnostic use only. +** +**
  • [[SQLITE_FCNTL_PRAGMA]] +** ^Whenever a [PRAGMA] statement is parsed, an [SQLITE_FCNTL_PRAGMA] +** file control is sent to the open [sqlite3_file] object corresponding +** to the database file to which the pragma statement refers. ^The argument +** to the [SQLITE_FCNTL_PRAGMA] file control is an array of +** pointers to strings (char**) in which the second element of the array +** is the name of the pragma and the third element is the argument to the +** pragma or NULL if the pragma has no argument. ^The handler for an +** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element +** of the char** argument point to a string obtained from [sqlite3_mprintf()] +** or the equivalent and that string will become the result of the pragma or +** the error message if the pragma fails. ^If the +** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal +** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] +** file control returns [SQLITE_OK], then the parser assumes that the +** VFS has handled the PRAGMA itself and the parser generates a no-op +** prepared statement. ^If the [SQLITE_FCNTL_PRAGMA] file control returns +** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means +** that the VFS encountered an error while handling the [PRAGMA] and the +** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] +** file control occurs at the beginning of pragma statement analysis and so +** it is able to override built-in [PRAGMA] statements. +** +**
  • [[SQLITE_FCNTL_BUSYHANDLER]] +** ^This file-control may be invoked by SQLite on the database file handle +** shortly after it is opened in order to provide a custom VFS with access +** to the connections busy-handler callback. The argument is of type (void **) +** - an array of two (void *) values. The first (void *) actually points +** to a function of type (int (*)(void *)). In order to invoke the connections +** busy-handler, this function should be invoked with the second (void *) in +** the array as the only argument. If it returns non-zero, then the operation +** should be retried. If it returns zero, the custom VFS should abandon the +** current operation. +** +**
  • [[SQLITE_FCNTL_TEMPFILENAME]] +** ^Application can invoke this file-control to have SQLite generate a +** temporary filename using the same algorithm that is followed to generate +** temporary filenames for TEMP tables and other internal uses. The +** argument should be a char** which will be filled with the filename +** written into memory obtained from [sqlite3_malloc()]. The caller should +** invoke [sqlite3_free()] on the result to avoid a memory leak. +** +**
+*/ +#define SQLITE_FCNTL_LOCKSTATE 1 +#define SQLITE_GET_LOCKPROXYFILE 2 +#define SQLITE_SET_LOCKPROXYFILE 3 +#define SQLITE_LAST_ERRNO 4 +#define SQLITE_FCNTL_SIZE_HINT 5 +#define SQLITE_FCNTL_CHUNK_SIZE 6 +#define SQLITE_FCNTL_FILE_POINTER 7 +#define SQLITE_FCNTL_SYNC_OMITTED 8 +#define SQLITE_FCNTL_WIN32_AV_RETRY 9 +#define SQLITE_FCNTL_PERSIST_WAL 10 +#define SQLITE_FCNTL_OVERWRITE 11 +#define SQLITE_FCNTL_VFSNAME 12 +#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 +#define SQLITE_FCNTL_PRAGMA 14 +#define SQLITE_FCNTL_BUSYHANDLER 15 +#define SQLITE_FCNTL_TEMPFILENAME 16 + +/* +** CAPI3REF: Mutex Handle +** +** The mutex module within SQLite defines [sqlite3_mutex] to be an +** abstract type for a mutex object. The SQLite core never looks +** at the internal representation of an [sqlite3_mutex]. It only +** deals with pointers to the [sqlite3_mutex] object. +** +** Mutexes are created using [sqlite3_mutex_alloc()]. +*/ +typedef struct sqlite3_mutex sqlite3_mutex; + +/* +** CAPI3REF: OS Interface Object +** +** An instance of the sqlite3_vfs object defines the interface between +** the SQLite core and the underlying operating system. The "vfs" +** in the name of the object stands for "virtual file system". See +** the [VFS | VFS documentation] for further information. +** +** The value of the iVersion field is initially 1 but may be larger in +** future versions of SQLite. Additional fields may be appended to this +** object when the iVersion value is increased. Note that the structure +** of the sqlite3_vfs object changes in the transaction between +** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not +** modified. +** +** The szOsFile field is the size of the subclassed [sqlite3_file] +** structure used by this VFS. mxPathname is the maximum length of +** a pathname in this VFS. +** +** Registered sqlite3_vfs objects are kept on a linked list formed by +** the pNext pointer. The [sqlite3_vfs_register()] +** and [sqlite3_vfs_unregister()] interfaces manage this list +** in a thread-safe way. The [sqlite3_vfs_find()] interface +** searches the list. Neither the application code nor the VFS +** implementation should use the pNext pointer. +** +** The pNext field is the only field in the sqlite3_vfs +** structure that SQLite will ever modify. SQLite will only access +** or modify this field while holding a particular static mutex. +** The application should never modify anything within the sqlite3_vfs +** object once the object has been registered. +** +** The zName field holds the name of the VFS module. The name must +** be unique across all VFS modules. +** +** [[sqlite3_vfs.xOpen]] +** ^SQLite guarantees that the zFilename parameter to xOpen +** is either a NULL pointer or string obtained +** from xFullPathname() with an optional suffix added. +** ^If a suffix is added to the zFilename parameter, it will +** consist of a single "-" character followed by no more than +** 11 alphanumeric and/or "-" characters. +** ^SQLite further guarantees that +** the string will be valid and unchanged until xClose() is +** called. Because of the previous sentence, +** the [sqlite3_file] can safely store a pointer to the +** filename if it needs to remember the filename for some reason. +** If the zFilename parameter to xOpen is a NULL pointer then xOpen +** must invent its own temporary name for the file. ^Whenever the +** xFilename parameter is NULL it will also be the case that the +** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. +** +** The flags argument to xOpen() includes all bits set in +** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +** or [sqlite3_open16()] is used, then flags includes at least +** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. +** If xOpen() opens a file read-only then it sets *pOutFlags to +** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. +** +** ^(SQLite will also add one of the following flags to the xOpen() +** call, depending on the object being opened: +** +**
    +**
  • [SQLITE_OPEN_MAIN_DB] +**
  • [SQLITE_OPEN_MAIN_JOURNAL] +**
  • [SQLITE_OPEN_TEMP_DB] +**
  • [SQLITE_OPEN_TEMP_JOURNAL] +**
  • [SQLITE_OPEN_TRANSIENT_DB] +**
  • [SQLITE_OPEN_SUBJOURNAL] +**
  • [SQLITE_OPEN_MASTER_JOURNAL] +**
  • [SQLITE_OPEN_WAL] +**
)^ +** +** The file I/O implementation can use the object type flags to +** change the way it deals with files. For example, an application +** that does not care about crash recovery or rollback might make +** the open of a journal file a no-op. Writes to this journal would +** also be no-ops, and any attempt to read the journal would return +** SQLITE_IOERR. Or the implementation might recognize that a database +** file will be doing page-aligned sector reads and writes in a random +** order and set up its I/O subsystem accordingly. +** +** SQLite might also add one of the following flags to the xOpen method: +** +**
    +**
  • [SQLITE_OPEN_DELETEONCLOSE] +**
  • [SQLITE_OPEN_EXCLUSIVE] +**
+** +** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE] +** will be set for TEMP databases and their journals, transient +** databases, and subjournals. +** +** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction +** with the [SQLITE_OPEN_CREATE] flag, which are both directly +** analogous to the O_EXCL and O_CREAT flags of the POSIX open() +** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the +** SQLITE_OPEN_CREATE, is used to indicate that file should always +** be created, and that it is an error if it already exists. +** It is not used to indicate the file should be opened +** for exclusive access. +** +** ^At least szOsFile bytes of memory are allocated by SQLite +** to hold the [sqlite3_file] structure passed as the third +** argument to xOpen. The xOpen method does not have to +** allocate the structure; it should just fill it in. Note that +** the xOpen method must set the sqlite3_file.pMethods to either +** a valid [sqlite3_io_methods] object or to NULL. xOpen must do +** this even if the open fails. SQLite expects that the sqlite3_file.pMethods +** element will be valid after xOpen returns regardless of the success +** or failure of the xOpen call. +** +** [[sqlite3_vfs.xAccess]] +** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to +** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] +** to test whether a file is at least readable. The file can be a +** directory. +** +** ^SQLite will always allocate at least mxPathname+1 bytes for the +** output buffer xFullPathname. The exact size of the output buffer +** is also passed as a parameter to both methods. If the output buffer +** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is +** handled as a fatal error by SQLite, vfs implementations should endeavor +** to prevent this by setting mxPathname to a sufficiently large value. +** +** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64() +** interfaces are not strictly a part of the filesystem, but they are +** included in the VFS structure for completeness. +** The xRandomness() function attempts to return nBytes bytes +** of good-quality randomness into zOut. The return value is +** the actual number of bytes of randomness obtained. +** The xSleep() method causes the calling thread to sleep for at +** least the number of microseconds given. ^The xCurrentTime() +** method returns a Julian Day Number for the current date and time as +** a floating point value. +** ^The xCurrentTimeInt64() method returns, as an integer, the Julian +** Day Number multiplied by 86400000 (the number of milliseconds in +** a 24-hour day). +** ^SQLite will use the xCurrentTimeInt64() method to get the current +** date and time if that method is available (if iVersion is 2 or +** greater and the function pointer is not NULL) and will fall back +** to xCurrentTime() if xCurrentTimeInt64() is unavailable. +** +** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces +** are not used by the SQLite core. These optional interfaces are provided +** by some VFSes to facilitate testing of the VFS code. By overriding +** system calls with functions under its control, a test program can +** simulate faults and error conditions that would otherwise be difficult +** or impossible to induce. The set of system calls that can be overridden +** varies from one VFS to another, and from one version of the same VFS to the +** next. Applications that use these interfaces must be prepared for any +** or all of these interfaces to be NULL or for their behavior to change +** from one release to the next. Applications must not attempt to access +** any of these methods if the iVersion of the VFS is less than 3. +*/ +typedef struct sqlite3_vfs sqlite3_vfs; +typedef void (*sqlite3_syscall_ptr)(void); +struct sqlite3_vfs { + int iVersion; /* Structure version number (currently 3) */ + int szOsFile; /* Size of subclassed sqlite3_file */ + int mxPathname; /* Maximum file pathname length */ + sqlite3_vfs *pNext; /* Next registered VFS */ + const char *zName; /* Name of this virtual file system */ + void *pAppData; /* Pointer to application-specific data */ + int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, + int flags, int *pOutFlags); + int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); + int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); + int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); + void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); + void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); + void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); + void (*xDlClose)(sqlite3_vfs*, void*); + int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); + int (*xSleep)(sqlite3_vfs*, int microseconds); + int (*xCurrentTime)(sqlite3_vfs*, double*); + int (*xGetLastError)(sqlite3_vfs*, int, char *); + /* + ** The methods above are in version 1 of the sqlite_vfs object + ** definition. Those that follow are added in version 2 or later + */ + int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*); + /* + ** The methods above are in versions 1 and 2 of the sqlite_vfs object. + ** Those below are for version 3 and greater. + */ + int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr); + sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName); + const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName); + /* + ** The methods above are in versions 1 through 3 of the sqlite_vfs object. + ** New fields may be appended in figure versions. The iVersion + ** value will increment whenever this happens. + */ +}; + +/* +** CAPI3REF: Flags for the xAccess VFS method +** +** These integer constants can be used as the third parameter to +** the xAccess method of an [sqlite3_vfs] object. They determine +** what kind of permissions the xAccess method is looking for. +** With SQLITE_ACCESS_EXISTS, the xAccess method +** simply checks whether the file exists. +** With SQLITE_ACCESS_READWRITE, the xAccess method +** checks whether the named directory is both readable and writable +** (in other words, if files can be added, removed, and renamed within +** the directory). +** The SQLITE_ACCESS_READWRITE constant is currently used only by the +** [temp_store_directory pragma], though this could change in a future +** release of SQLite. +** With SQLITE_ACCESS_READ, the xAccess method +** checks whether the file is readable. The SQLITE_ACCESS_READ constant is +** currently unused, though it might be used in a future release of +** SQLite. +*/ +#define SQLITE_ACCESS_EXISTS 0 +#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */ +#define SQLITE_ACCESS_READ 2 /* Unused */ + +/* +** CAPI3REF: Flags for the xShmLock VFS method +** +** These integer constants define the various locking operations +** allowed by the xShmLock method of [sqlite3_io_methods]. The +** following are the only legal combinations of flags to the +** xShmLock method: +** +**
    +**
  • SQLITE_SHM_LOCK | SQLITE_SHM_SHARED +**
  • SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE +**
  • SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED +**
  • SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE +**
+** +** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as +** was given no the corresponding lock. +** +** The xShmLock method can transition between unlocked and SHARED or +** between unlocked and EXCLUSIVE. It cannot transition between SHARED +** and EXCLUSIVE. +*/ +#define SQLITE_SHM_UNLOCK 1 +#define SQLITE_SHM_LOCK 2 +#define SQLITE_SHM_SHARED 4 +#define SQLITE_SHM_EXCLUSIVE 8 + +/* +** CAPI3REF: Maximum xShmLock index +** +** The xShmLock method on [sqlite3_io_methods] may use values +** between 0 and this upper bound as its "offset" argument. +** The SQLite core will never attempt to acquire or release a +** lock outside of this range +*/ +#define SQLITE_SHM_NLOCK 8 + + +/* +** CAPI3REF: Initialize The SQLite Library +** +** ^The sqlite3_initialize() routine initializes the +** SQLite library. ^The sqlite3_shutdown() routine +** deallocates any resources that were allocated by sqlite3_initialize(). +** These routines are designed to aid in process initialization and +** shutdown on embedded systems. Workstation applications using +** SQLite normally do not need to invoke either of these routines. +** +** A call to sqlite3_initialize() is an "effective" call if it is +** the first time sqlite3_initialize() is invoked during the lifetime of +** the process, or if it is the first time sqlite3_initialize() is invoked +** following a call to sqlite3_shutdown(). ^(Only an effective call +** of sqlite3_initialize() does any initialization. All other calls +** are harmless no-ops.)^ +** +** A call to sqlite3_shutdown() is an "effective" call if it is the first +** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only +** an effective call to sqlite3_shutdown() does any deinitialization. +** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^ +** +** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown() +** is not. The sqlite3_shutdown() interface must only be called from a +** single thread. All open [database connections] must be closed and all +** other SQLite resources must be deallocated prior to invoking +** sqlite3_shutdown(). +** +** Among other things, ^sqlite3_initialize() will invoke +** sqlite3_os_init(). Similarly, ^sqlite3_shutdown() +** will invoke sqlite3_os_end(). +** +** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success. +** ^If for some reason, sqlite3_initialize() is unable to initialize +** the library (perhaps it is unable to allocate a needed resource such +** as a mutex) it returns an [error code] other than [SQLITE_OK]. +** +** ^The sqlite3_initialize() routine is called internally by many other +** SQLite interfaces so that an application usually does not need to +** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] +** calls sqlite3_initialize() so the SQLite library will be automatically +** initialized when [sqlite3_open()] is called if it has not be initialized +** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT] +** compile-time option, then the automatic calls to sqlite3_initialize() +** are omitted and the application must call sqlite3_initialize() directly +** prior to using any other SQLite interface. For maximum portability, +** it is recommended that applications always invoke sqlite3_initialize() +** directly prior to using any other SQLite interface. Future releases +** of SQLite may require this. In other words, the behavior exhibited +** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the +** default behavior in some future release of SQLite. +** +** The sqlite3_os_init() routine does operating-system specific +** initialization of the SQLite library. The sqlite3_os_end() +** routine undoes the effect of sqlite3_os_init(). Typical tasks +** performed by these routines include allocation or deallocation +** of static resources, initialization of global variables, +** setting up a default [sqlite3_vfs] module, or setting up +** a default configuration using [sqlite3_config()]. +** +** The application should never invoke either sqlite3_os_init() +** or sqlite3_os_end() directly. The application should only invoke +** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() +** interface is called automatically by sqlite3_initialize() and +** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate +** implementations for sqlite3_os_init() and sqlite3_os_end() +** are built into SQLite when it is compiled for Unix, Windows, or OS/2. +** When [custom builds | built for other platforms] +** (using the [SQLITE_OS_OTHER=1] compile-time +** option) the application must supply a suitable implementation for +** sqlite3_os_init() and sqlite3_os_end(). An application-supplied +** implementation of sqlite3_os_init() or sqlite3_os_end() +** must return [SQLITE_OK] on success and some other [error code] upon +** failure. +*/ +SQLITE_API int sqlite3_initialize(void); +SQLITE_API int sqlite3_shutdown(void); +SQLITE_API int sqlite3_os_init(void); +SQLITE_API int sqlite3_os_end(void); + +/* +** CAPI3REF: Configuring The SQLite Library +** +** The sqlite3_config() interface is used to make global configuration +** changes to SQLite in order to tune SQLite to the specific needs of +** the application. The default configuration is recommended for most +** applications and so this routine is usually not necessary. It is +** provided to support rare applications with unusual needs. +** +** The sqlite3_config() interface is not threadsafe. The application +** must insure that no other SQLite interfaces are invoked by other +** threads while sqlite3_config() is running. Furthermore, sqlite3_config() +** may only be invoked prior to library initialization using +** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. +** ^If sqlite3_config() is called after [sqlite3_initialize()] and before +** [sqlite3_shutdown()] then it will return SQLITE_MISUSE. +** Note, however, that ^sqlite3_config() can be called as part of the +** implementation of an application-defined [sqlite3_os_init()]. +** +** The first argument to sqlite3_config() is an integer +** [configuration option] that determines +** what property of SQLite is to be configured. Subsequent arguments +** vary depending on the [configuration option] +** in the first argument. +** +** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. +** ^If the option is unknown or SQLite is unable to set the option +** then this routine returns a non-zero [error code]. +*/ +SQLITE_API int sqlite3_config(int, ...); + +/* +** CAPI3REF: Configure database connections +** +** The sqlite3_db_config() interface is used to make configuration +** changes to a [database connection]. The interface is similar to +** [sqlite3_config()] except that the changes apply to a single +** [database connection] (specified in the first argument). +** +** The second argument to sqlite3_db_config(D,V,...) is the +** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code +** that indicates what aspect of the [database connection] is being configured. +** Subsequent arguments vary depending on the configuration verb. +** +** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if +** the call is considered successful. +*/ +SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Memory Allocation Routines +** +** An instance of this object defines the interface between SQLite +** and low-level memory allocation routines. +** +** This object is used in only one place in the SQLite interface. +** A pointer to an instance of this object is the argument to +** [sqlite3_config()] when the configuration option is +** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. +** By creating an instance of this object +** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) +** during configuration, an application can specify an alternative +** memory allocation subsystem for SQLite to use for all of its +** dynamic memory needs. +** +** Note that SQLite comes with several [built-in memory allocators] +** that are perfectly adequate for the overwhelming majority of applications +** and that this object is only useful to a tiny minority of applications +** with specialized memory allocation requirements. This object is +** also used during testing of SQLite in order to specify an alternative +** memory allocator that simulates memory out-of-memory conditions in +** order to verify that SQLite recovers gracefully from such +** conditions. +** +** The xMalloc, xRealloc, and xFree methods must work like the +** malloc(), realloc() and free() functions from the standard C library. +** ^SQLite guarantees that the second argument to +** xRealloc is always a value returned by a prior call to xRoundup. +** +** xSize should return the allocated size of a memory allocation +** previously obtained from xMalloc or xRealloc. The allocated size +** is always at least as big as the requested size but may be larger. +** +** The xRoundup method returns what would be the allocated size of +** a memory allocation given a particular requested size. Most memory +** allocators round up memory allocations at least to the next multiple +** of 8. Some allocators round up to a larger multiple or to a power of 2. +** Every memory allocation request coming in through [sqlite3_malloc()] +** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, +** that causes the corresponding memory allocation to fail. +** +** The xInit method initializes the memory allocator. (For example, +** it might allocate any require mutexes or initialize internal data +** structures. The xShutdown method is invoked (indirectly) by +** [sqlite3_shutdown()] and should deallocate any resources acquired +** by xInit. The pAppData pointer is used as the only parameter to +** xInit and xShutdown. +** +** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes +** the xInit method, so the xInit method need not be threadsafe. The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. For all other methods, SQLite +** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the +** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which +** it is by default) and so the methods are automatically serialized. +** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other +** methods must be threadsafe or else make their own arrangements for +** serialization. +** +** SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +*/ +typedef struct sqlite3_mem_methods sqlite3_mem_methods; +struct sqlite3_mem_methods { + void *(*xMalloc)(int); /* Memory allocation function */ + void (*xFree)(void*); /* Free a prior allocation */ + void *(*xRealloc)(void*,int); /* Resize an allocation */ + int (*xSize)(void*); /* Return the size of an allocation */ + int (*xRoundup)(int); /* Round up request size to allocation size */ + int (*xInit)(void*); /* Initialize the memory allocator */ + void (*xShutdown)(void*); /* Deinitialize the memory allocator */ + void *pAppData; /* Argument to xInit() and xShutdown() */ +}; + +/* +** CAPI3REF: Configuration Options +** KEYWORDS: {configuration option} +** +** These constants are the available integer configuration options that +** can be passed as the first argument to the [sqlite3_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_config()] to make sure that +** the call worked. The [sqlite3_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+** [[SQLITE_CONFIG_SINGLETHREAD]]
SQLITE_CONFIG_SINGLETHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Single-thread. In other words, it disables +** all mutexing and puts SQLite into a mode where it can only be used +** by a single thread. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to change the [threading mode] from its default +** value of Single-thread and so [sqlite3_config()] will return +** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD +** configuration option.
+** +** [[SQLITE_CONFIG_MULTITHREAD]]
SQLITE_CONFIG_MULTITHREAD
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Multi-thread. In other words, it disables +** mutexing on [database connection] and [prepared statement] objects. +** The application is responsible for serializing access to +** [database connections] and [prepared statements]. But other mutexes +** are enabled so that SQLite will be safe to use in a multi-threaded +** environment as long as no two threads attempt to use the same +** [database connection] at the same time. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Multi-thread [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_MULTITHREAD configuration option.
+** +** [[SQLITE_CONFIG_SERIALIZED]]
SQLITE_CONFIG_SERIALIZED
+**
There are no arguments to this option. ^This option sets the +** [threading mode] to Serialized. In other words, this option enables +** all mutexes including the recursive +** mutexes on [database connection] and [prepared statement] objects. +** In this mode (which is the default when SQLite is compiled with +** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access +** to [database connections] and [prepared statements] so that the +** application is free to use the same [database connection] or the +** same [prepared statement] in different threads at the same time. +** ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** it is not possible to set the Serialized [threading mode] and +** [sqlite3_config()] will return [SQLITE_ERROR] if called with the +** SQLITE_CONFIG_SERIALIZED configuration option.
+** +** [[SQLITE_CONFIG_MALLOC]]
SQLITE_CONFIG_MALLOC
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mem_methods] structure. The argument specifies +** alternative low-level memory allocation routines to be used in place of +** the memory allocation routines built into SQLite.)^ ^SQLite makes +** its own private copy of the content of the [sqlite3_mem_methods] structure +** before the [sqlite3_config()] call returns.
+** +** [[SQLITE_CONFIG_GETMALLOC]]
SQLITE_CONFIG_GETMALLOC
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods] +** structure is filled with the currently defined memory allocation routines.)^ +** This option can be used to overload the default memory allocation +** routines with a wrapper that simulations memory allocation failure or +** tracks memory usage, for example.
+** +** [[SQLITE_CONFIG_MEMSTATUS]]
SQLITE_CONFIG_MEMSTATUS
+**
^This option takes single argument of type int, interpreted as a +** boolean, which enables or disables the collection of memory allocation +** statistics. ^(When memory allocation statistics are disabled, the +** following SQLite interfaces become non-operational: +**
    +**
  • [sqlite3_memory_used()] +**
  • [sqlite3_memory_highwater()] +**
  • [sqlite3_soft_heap_limit64()] +**
  • [sqlite3_status()] +**
)^ +** ^Memory allocation statistics are enabled by default unless SQLite is +** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory +** allocation statistics are disabled by default. +**
+** +** [[SQLITE_CONFIG_SCRATCH]]
SQLITE_CONFIG_SCRATCH
+**
^This option specifies a static memory buffer that SQLite can use for +** scratch memory. There are three arguments: A pointer an 8-byte +** aligned memory buffer from which the scratch allocations will be +** drawn, the size of each scratch allocation (sz), +** and the maximum number of scratch allocations (N). The sz +** argument must be a multiple of 16. +** The first argument must be a pointer to an 8-byte aligned buffer +** of at least sz*N bytes of memory. +** ^SQLite will use no more than two scratch buffers per thread. So +** N should be set to twice the expected maximum number of threads. +** ^SQLite will never require a scratch buffer that is more than 6 +** times the database page size. ^If SQLite needs needs additional +** scratch memory beyond what is provided by this configuration option, then +** [sqlite3_malloc()] will be used to obtain the memory needed.
+** +** [[SQLITE_CONFIG_PAGECACHE]]
SQLITE_CONFIG_PAGECACHE
+**
^This option specifies a static memory buffer that SQLite can use for +** the database page cache with the default page cache implementation. +** This configuration should not be used if an application-define page +** cache implementation is loaded using the SQLITE_CONFIG_PCACHE2 option. +** There are three arguments to this option: A pointer to 8-byte aligned +** memory, the size of each page buffer (sz), and the number of pages (N). +** The sz argument should be the size of the largest database page +** (a power of two between 512 and 32768) plus a little extra for each +** page header. ^The page header size is 20 to 40 bytes depending on +** the host architecture. ^It is harmless, apart from the wasted memory, +** to make sz a little too large. The first +** argument should point to an allocation of at least sz*N bytes of memory. +** ^SQLite will use the memory provided by the first argument to satisfy its +** memory needs for the first N pages that it adds to cache. ^If additional +** page cache memory is needed beyond what is provided by this option, then +** SQLite goes to [sqlite3_malloc()] for the additional storage space. +** The pointer in the first argument must +** be aligned to an 8-byte boundary or subsequent behavior of SQLite +** will be undefined.
+** +** [[SQLITE_CONFIG_HEAP]]
SQLITE_CONFIG_HEAP
+**
^This option specifies a static memory buffer that SQLite will use +** for all of its dynamic memory allocation needs beyond those provided +** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE]. +** There are three arguments: An 8-byte aligned pointer to the memory, +** the number of bytes in the memory buffer, and the minimum allocation size. +** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts +** to using its default memory allocator (the system malloc() implementation), +** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the +** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or +** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory +** allocator is engaged to handle all of SQLites memory allocation needs. +** The first pointer (the memory pointer) must be aligned to an 8-byte +** boundary or subsequent behavior of SQLite will be undefined. +** The minimum allocation size is capped at 2**12. Reasonable values +** for the minimum allocation size are 2**5 through 2**8.
+** +** [[SQLITE_CONFIG_MUTEX]]
SQLITE_CONFIG_MUTEX
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mutex_methods] structure. The argument specifies +** alternative low-level mutex routines to be used in place +** the mutex routines built into SQLite.)^ ^SQLite makes a copy of the +** content of the [sqlite3_mutex_methods] structure before the call to +** [sqlite3_config()] returns. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_GETMUTEX]]
SQLITE_CONFIG_GETMUTEX
+**
^(This option takes a single argument which is a pointer to an +** instance of the [sqlite3_mutex_methods] structure. The +** [sqlite3_mutex_methods] +** structure is filled with the currently defined mutex routines.)^ +** This option can be used to overload the default mutex allocation +** routines with a wrapper used to track mutex usage for performance +** profiling or testing, for example. ^If SQLite is compiled with +** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then +** the entire mutexing subsystem is omitted from the build and hence calls to +** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will +** return [SQLITE_ERROR].
+** +** [[SQLITE_CONFIG_LOOKASIDE]]
SQLITE_CONFIG_LOOKASIDE
+**
^(This option takes two arguments that determine the default +** memory allocation for the lookaside memory allocator on each +** [database connection]. The first argument is the +** size of each lookaside buffer slot and the second is the number of +** slots allocated to each database connection.)^ ^(This option sets the +** default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] +** verb to [sqlite3_db_config()] can be used to change the lookaside +** configuration on individual connections.)^
+** +** [[SQLITE_CONFIG_PCACHE2]]
SQLITE_CONFIG_PCACHE2
+**
^(This option takes a single argument which is a pointer to +** an [sqlite3_pcache_methods2] object. This object specifies the interface +** to a custom page cache implementation.)^ ^SQLite makes a copy of the +** object and uses it for page cache memory allocations.
+** +** [[SQLITE_CONFIG_GETPCACHE2]]
SQLITE_CONFIG_GETPCACHE2
+**
^(This option takes a single argument which is a pointer to an +** [sqlite3_pcache_methods2] object. SQLite copies of the current +** page cache implementation into that object.)^
+** +** [[SQLITE_CONFIG_LOG]]
SQLITE_CONFIG_LOG
+**
^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a +** function with a call signature of void(*)(void*,int,const char*), +** and a pointer to void. ^If the function pointer is not NULL, it is +** invoked by [sqlite3_log()] to process each logging event. ^If the +** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op. +** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is +** passed through as the first parameter to the application-defined logger +** function whenever that function is invoked. ^The second parameter to +** the logger function is a copy of the first parameter to the corresponding +** [sqlite3_log()] call and is intended to be a [result code] or an +** [extended result code]. ^The third parameter passed to the logger is +** log message after formatting via [sqlite3_snprintf()]. +** The SQLite logging interface is not reentrant; the logger function +** supplied by the application must not invoke any SQLite interface. +** In a multi-threaded application, the application-defined logger +** function must be threadsafe.
+** +** [[SQLITE_CONFIG_URI]]
SQLITE_CONFIG_URI +**
This option takes a single argument of type int. If non-zero, then +** URI handling is globally enabled. If the parameter is zero, then URI handling +** is globally disabled. If URI handling is globally enabled, all filenames +** passed to [sqlite3_open()], [sqlite3_open_v2()], [sqlite3_open16()] or +** specified as part of [ATTACH] commands are interpreted as URIs, regardless +** of whether or not the [SQLITE_OPEN_URI] flag is set when the database +** connection is opened. If it is globally disabled, filenames are +** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the +** database connection is opened. By default, URI handling is globally +** disabled. The default value may be changed by compiling with the +** [SQLITE_USE_URI] symbol defined. +** +** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]]
SQLITE_CONFIG_COVERING_INDEX_SCAN +**
This option takes a single integer argument which is interpreted as +** a boolean in order to enable or disable the use of covering indices for +** full table scans in the query optimizer. The default setting is determined +** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on" +** if that compile-time option is omitted. +** The ability to disable the use of covering indices for full table scans +** is because some incorrectly coded legacy applications might malfunction +** malfunction when the optimization is enabled. Providing the ability to +** disable the optimization allows the older, buggy application code to work +** without change even with newer versions of SQLite. +** +** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]] +**
SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE +**
These options are obsolete and should not be used by new code. +** They are retained for backwards compatibility but are now no-ops. +**
+** +** [[SQLITE_CONFIG_SQLLOG]] +**

&1t-5-efMpIe6gUZ^Uh4{n&X|RJU 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 vvUWo=%i3S(^EDgq1lGCe=Y!a9eaXp3%-PKQ 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�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 yl|D8&S^K`8 zkwtEAK~JXKp4`Idj-9`Z$0p-)`!02Lza1U${nUKC&5dQzvE8M8|6j_|-n(h*QPX-ISt>A+@0av7`o=;uFX59PmVD>Fl#U@2%O1YX z>^S(PK54({4?MdCcZp9L1G9-isYx z+YiQuo=1z*XdJJ_C;z;~o?mdrip!4|Z+E?pu|~_+c>B>W)AE)6&O^R@x5CO)dodnf z@>AOL0e7a#(4yP}^ z?H$?Lrr%dM8N})IG-{2JdbbgBR$N)n`{^02T|buH8^H5_*I0i@eb$;+dZBbb(%9PJ z1;<(c$}R}jjdg1SbbcBh?|X@T{C#;5|65$2w5|(jTX9v{BH5kx39Qqg!_Nh!w6C=E zR(N?nJzwjq_!?3;@(MZ+tmnMd=jeylkUF2B{6F8}&QM`Lh+SewBU?F+z6g(xS1ZP> z_0!3}(m9Z{jn!Dl7CYA*q8Pm9N7>)pQ13~QJ^hKb#X29Vd>^CFgKmGXz2kU{TlpF@ znfoEKv9fu;BK|JAGx?=4Rg}Rmjd$rUYxBdF9@byNt8}q#H%eRg4|(%GB{$J5L;&x%EAlhc_Cz5SM*iu)46<#gi-r8Q4MFY(GQ zORsF8eDI-ee@6ObZ3A%Z)jgpzWhzf_-bDGD^U$qFN_;+XR_)=$@#y;ui9s8QzY4x* z+;u~2-mZgIePf`ufcI9112~5l>40dcqpsqpnsb+vmW`~1A4h(~Sy$>vPNnWya_AZU z+*G|cD$-Zp>5)H&a*d@Uf!U{ej}F^$Fb_W7dT-iBy&Obqr6O<(Ue6pAla6q2wDY}q zuK5|=vN5Szc;U}&oCAK!?c69iD_`{$lhHhFV?5*wxA?|h@)O0-vJ+o0KHj|k{EcUe zYJtt8uGY4Ceu=ouaOL%h<>AL!eG`6cg{3Ri9eGfkKYh#7zyvB{>`XBUB zw!->6(60Erc&t6R$1?hI3U;v&dU*cX(ix}!kb7r{e|CPpqepy*!|l$1o0WwZqmfa7 z{*OinrLUjSGsxI!?Yqu%@{Hrmg#WmMpXYQyb>_i8@qRS4pGZchFdwL|f^URArALvz zj_vt7y9>azRI>}y=cp111%O#0~guemSmJ6OfF+8ICW6&Wyk9s`lx9q?CPT||;@Rg7!{gIs!?XxMS4t`0 z$n)7H)Q`r;9XzKo;NZ3J>r(L>TewVknFrK2rNzr@3oOsNySAlyCSA!*732Ro9l@%AulD(Q;$7wRaJZ!5ft1BgbYRY(2x zYYm;fe-vNoajxB5o7eLGVt%{0hTSs29OAcx-_j4~n>R@3vOYVL%Ri^1Gs{Jc(c%K0 z$!A{kV@*64EwX9FqSM-#jR!COea|%jcGRu`+L*7U`+f1XE(f-P_jUSr_{dJ~%G+`9 zTZw3mp?9l4$~#b`tLneTzS^?>A@UNQ#6_w1|JZS)GU>F+f~n~;@ls{7tINQtJ!;)s zxC&<`n0tvjGM#7z$z~1+IQs}ZMnu~f!@)=*p|)s$jO}t&Q&ZAJ{5=;(0mfU z<1m+I&C2^uIuE?{wMZWXliH7RZRFBN>CAaf#Z1tTK(Cc5!@frGgBG+4||71&s0gi zvxxINlLh8+U^E{HW*RV^SzxvTBVGt*A~5T-z_b9PzDXyFfDyeucJQF%e^7u;=DBj= z**%UpQrKyqYteazDOqrib~pt;1e{hkz+2?_RKh!h&n&odzuqSk@~iJAPeIN_1!o-m z0q}AEoo4{-Sdkwso%ga(Y(;as^h)FDapn^3TdU1*H!=pFY?%Dzfy~D*@QkeBr8Dpl+IAo=?*0y@5cL{Zafg28(-SBRA^j&Cl)!IPGweBL;;OMnq|K*ED^7TBJ z>^k(=HH2)Er$e^j-=RVNp>2y;Q@Tykw5hegtl}t6H?U+=s=R<_qf~B?!^K(3cM~U& zo%8sl7yX@ns!uvo*qH&NJjva|ZKB+d6EFXBocz_U=>I76i;gGw7L9%v5u1tgLH1ku zKe#$7pPNz6`374qxd`9&;M>bucNj6L7x>kgMc>a|*i5DW!nvtm{Q2k+*&l-punG28 zwoCU`=KN}|lWa#LTk%19AseQ&j}eC08sQujqf2__?acfBV0mxj!g=8L@}(_{N6({+ zN3!kG1MwUh4yZq4uyyF3je+~vUhC6=vCny#KOXI~?&3GJK7VpRzImJXMP#@y+}mEVbRhGY z_z$m5KNJ6})ji|1_=0xdME<7l|LJaD)%yk7Cy4wW>AhkccO3l2l%J&LRr!ZK%F#W= zVS1x+e#y5FGM*1B1|?ri`)8}5QGL`N%RfhRQ;)rm_?~pO{inE2UX4GbIZ^Q`ohJ}K z#20;^UApRRm}uVpmx$-eSKGJIwqy{;w+eij{*Kp&6VY-(7FrZn%SOxn8MLg*Ld)#G zlNRZ-cpUG~AaLlp?%w3%d89e{sy)$O|3G+U{SEZxc)Zo#nZ|&4TOaF>@-KZdvK8WU zNtV97CrjVra?c!ll8LuNFa1X(BiWGW7)w@nk@+5%mJj=aPouxGYrmt8_@nfR#(BK0 zZ@IRlQ@$;=d%U)OmZdEp1NAh-&&c_*`2Lp8uZq?~ z&h-6-vk?O_`Z^ukm|1^8to|vn`iH5nJ=r*~>ax_oG*YyJn8+?0%Z}`1|+v zOP}L?`N{kh1)03Cb3;tWW+6jA4&)yxCat;hDE-p8fD-o(R1Rv-aBAdF$v@M4%-m~Zl79W>?Sl5c z?VQY*(D(+gYX&sLQ^hllG)7FK0cqBr!|m2!?F1{QGajEQde_*W?ilEv}V>G!pG6k zwbXl)XI|BoWSI${iXqVF26!z$`5D1uo9d`59?hZN9Ozd4+AMTvEiAdJ{Msz#idAQ} zTSVSy>Uh1{`qg)i=sxn#BYP;HvwK zv}i3`0?!^K=01hFR_Q4PXB@2gb!5AAUS8vC9d!8hhx$4q3$CeI+Mk{!PqC+|&?Ftl zH_e|)o42`j@^t0H|5EaPN*+FUPnz*(^e&RufbqU@4_%MFgJ9UE0oFhDdhczRKcnyb zI%~T|(T?WY7212iW-HdDc|@@$>7+d~Pr3Y+XYYvgQt(TAfsflp&G#DHf`4Bx@PhF^ zfPIfT{Em-b--lz)7I~W7nPJ&0^@~2_V8e!JOn6$vYuRLtkMUPU@)ZwNCtF)_yZGkF zEA4k)<(oc|aXwkG4&fc*`ZkpHukL+JO}2Cx?`#!cJq~zQ~ne9@RXNZQl3$ zks1fmyHI?D-pprReB8*dr_~NTx9gfrSlI*F3AOn>N3-BrgW2_WCcJR7e_;3Zr5B<@ zG{m2g{Kavek?f&&v}<)JgNItniDw^J>7Vt9>`ykiWW)DZ20r>?@jbgd!Y4dm9TLag z)lU!_~$0CYSH8_t*UT^K&^-OfnnqOPD)Lu#?5SGdWt{DHcmV z;g9Ur|5bV(@AH|b7!bOseg*~D2ihD2&qa&uw)A;4dG|oS)=eRGhGo>zK1QzW7y3II zonME}7qh?jb<(RzzhURU|J%NtOMB4Xt@lxgXJg!b0{h^fo7|{0FhwfE24743#`=yU z(!OKCw7#!@_r|wgpAMej#;1RyGZCtj4bM3a&(P!Gc~g1>9_{7j6nA!?s^6)i}CkMw&<4<=no`YZ>dXWF#qCm5Zv&^O@* zk=A^v?=kk6CmA38{y^NHF*1;;Mb1}uj^9^{=e7vk@)lIHD?!yv-3Ne z-*NmZjyiSFj)OnFJw2Z&ex>=Li1JIY(}EcW%$^Jw%|n8bA0(K!3U(ZPIs*pXu`uU4 zn7zO}kpZK9E8!XGV0HoXSO!e4gE`&7Yy;-u448fnhJ8j$&st!1WWe-yF!F;$^De{~jGE{oB!*3puUFPd*MX^GE4GqccAltD`z{(>yDoEf8K ztE0us%Jap~T_+PKQ=oP3NQyFIsT^PAvaHaiY}sG##eU(KV~Q^l}l zr(Z;#dz|dN{QE)oE|({MppTF2q<$6ooi1PP1ZQ*}*iQYBeBr#);oOo@cLR0HfoYG` z)mljN>umBhugQN9PQ|VcZH?wKwXOL49O{<>HziB`52`-%UcBEA!`E8$?NNSraeWm> zY&rMOkbaS?i_7y`ewW&ppP+d2Xxgd}&QNPN)^pGkK$rJ>UxGF-hu2PkM>MNHij4_Z z9MAJHJa5PF#AUjc`rb#5k1x-=vnltqsDFO1SI<=2v&rbilLeeR2F~wk>KRPfG5lfr zc?231WAW>xTql#uqIRuc59}k7-+OFc*8#mtt-X}}Zg6|}$qqgjKFNNp1+U6)>WOE# z&fWgiwW+<4Dct{wd(CT-pZ3t}RTo}aU3lTj{RP;N1RKHw|43YdYYJB>R~^?{E-%N; z^mzkv+=LuABgZZH^DXR?j^53;KD*NUq<(*N8D*utl +5r9P%MCsIkUu(i$HDtu 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 literal 0 HcmV?d00001 diff --git a/smart_home_server/main.c b/smart_home_server/main.c new file mode 100755 index 0000000..1b0277e --- /dev/null +++ b/smart_home_server/main.c @@ -0,0 +1,34 @@ +/************************************************************************* + > File Name: main.c + > Author: lei + > Mail: + > Created Time: Thu 30 Aug 2018 09:14:46 AM CST + ************************************************************************/ + +#include +#include "./include/server.h" +#include "./include/camera_process.h" +#include +#include + +int main() +{ + pid_t ret; + int server_ret = 0; + //调用两个函数 + ret = fork(); + if(ret < 0) + { + perror("create process error"); + return -1; + } + if(ret == 0) + { + camera_process(); + } + else + server_ret = A9_process(); + + return 0; +} + diff --git a/smart_home_server/modul.c b/smart_home_server/modul.c new file mode 100755 index 0000000..8ab2a8e --- /dev/null +++ b/smart_home_server/modul.c @@ -0,0 +1,176 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "./include/serial.h" +#include "./include/server.h" + +#define REQ_DATA_SIZE 32 +#define HDR_DATA_SIZE 128 +#define ZGB_DATA_SIZE 36 + +extern int zgbfd; +extern pthread_mutex_t env_mutex; +extern char *p_shm; +extern char cmd_buf[5]; +struct env_char{ + char led_one; + char led_two; + char fan; + char h_tem; + char l_tem; + char h_hum; + char l_hum; + char first_light; + char second_light; + char third_light; + char forth_light; +}; +struct env_char env_char_data; +void read_cmd() +{ + read_shm(p_shm+11,cmd_buf,3); + printf("p_shm[11] = %d\r\n",p_shm[11]); + printf("p_shm[12] = %d\r\n",p_shm[12]); + printf("p_shm[13] = %d\r\n",p_shm[13]); + printf("cmd_buf[0] = %d\r\n",cmd_buf[0]); + printf("cmd_buf[1] = %d\r\n",cmd_buf[1]); + printf("cmd_buf[2] = %d\r\n",cmd_buf[2]); +} +int zigbee_init( char *devpath, int baudrate) +{ + return serial_init(devpath); +} + +int zigbee_get_dat(int fd) +{ + ssize_t ret; + unsigned char buf[ZGB_DATA_SIZE]; + memset(buf, 0, sizeof(buf)); + fprintf(stdout,"hi\n"); + ret = serial_recv_exact_nbytes(fd, buf, sizeof(buf)); + fprintf(stdout,"hi1\n"); + if (ret == sizeof(buf)) + { + if (buf[0] == 0xBB) + { + memset(&data, 0, sizeof(struct env)); + data.id = (int)buf[1]; + data.tem = (float)((buf[5]*10 + buf[4])/10) ; + data.hum = (float)((buf[7]*10 + buf[6])/10) ; + data.light = (int)((buf[23] << 24) + (buf[22] << 16) + (buf[21] << 8) + buf[20]); + + env_char_data.l_tem = buf[4]; + env_char_data.h_tem = buf[5]; + env_char_data.l_hum = buf[6]; + env_char_data.h_hum = buf[7]; + env_char_data.first_light = buf[20]; + env_char_data.second_light = buf[21]; + env_char_data.third_light = buf[22]; + env_char_data.forth_light = buf[23]; + + data.led = buf[24]; + data.fan = buf[25]; + data.buzz = buf[26]; + + env_char_data.led_one = buf[24]; + env_char_data.fan = buf[25]; + env_char_data.led_two = buf[27]; + } + } + return ret; +} + +int zigbee_exe_cmd(int fd, unsigned char *p) +{ + unsigned char buf[ZGB_DATA_SIZE] = {0xdd, 0x06, 0x24, 0x00, 0x00}; + if (strstr(p, "LIGHT_ON") != NULL){ + buf[4] = 0x00; + } else if (strstr(p, "LIGHT_OFF") != NULL){ + buf[4] = 0x01; + } else if (strstr(p, "BUZZ_ON") != NULL){ + buf[4] = 0x02; + } else if (strstr(p, "BUZZ_OFF") != NULL){ + buf[4] = 0x03; + } else if (strstr(p, "FAN_ON") != NULL){ + buf[4] = 0x04; + } else if (strstr(p, "FAN_OFF") != NULL){ + buf[4] = 0x08; + } else if (strstr(p, "SHU_ON") != NULL){ + buf[4] = 0x09; + } else if (strstr(p, "SHU_OFF") != NULL){ + buf[4] = 0x0a; + } + + int ret = serial_send_exact_nbytes(fd, buf, sizeof(buf)); + + return ret; +} + + +void ctrl_led_one() +{ + if(cmd_buf[0]) + { + printf("cmd_buf[0] now = %d\r\n",cmd_buf[0]); + zigbee_exe_cmd(zgbfd,"LIGHT_ON"); //led1 + } + + else + { + printf("cmd_buf[0] now = %d\r\n",cmd_buf[0]); + zigbee_exe_cmd(zgbfd,"LIGHT_OFF"); + } +} + +void ctrl_led_two() +{ + if( cmd_buf[1]) + { + printf("cmd_buf[1] now = %d\r\n",cmd_buf[1]); + zigbee_exe_cmd(zgbfd,"SHU_ON"); //led2 + } + else + { + printf("cmd_buf[1] now = %d\r\n",cmd_buf[1]); + zigbee_exe_cmd(zgbfd,"SHU_OFF"); + } +} + +void ctrl_fan() +{ + if( cmd_buf[2]) + { + printf("cmd_buf[2] now = %d\r\n",cmd_buf[2]); + zigbee_exe_cmd(zgbfd,"FAN_ON"); //fan + } + else + { + printf("cmd_buf[2] now = %d\r\n",cmd_buf[2]); + zigbee_exe_cmd(zgbfd,"FAN_OFF"); + } +} +void send_cmd_m0(int signum) +{ + read_cmd(); + ctrl_fan(); + ctrl_led_one(); + ctrl_led_two(); +} + +int zigbee_exit(int fd) +{ + return serial_exit(fd); +} + + + diff --git a/smart_home_server/serial.c b/smart_home_server/serial.c new file mode 100755 index 0000000..6b0c882 --- /dev/null +++ b/smart_home_server/serial.c @@ -0,0 +1,251 @@ +#include /*标准输入输出定义*/ +#include /*标准函数库定义*/ +#include /*Unix 标准函数定义*/ +#include +#include +#include /*文件控制定义*/ +#include /*PPSIX 终端控制定义*/ +#include /*错误号定义*/ +#include +#include + +#include +#include + + +#define FALSE -1 +#define TRUE 0 + + +int serial_open(char *devpath) +{ + /*分别为com1，com2， com3对应 ttyUSB0 ttyUSB1 ttyUSB2 */ + int fd = open( devpath, O_RDWR|O_NOCTTY|O_NDELAY); + if (FALSE == fd){ + perror("Can't Open Serial Port"); + return(FALSE); + } + //恢复串口为阻塞状态 + if(fcntl(fd, F_SETFL, 0) < 0){ + printf("fcntl failed!\n"); + return(FALSE); + } else{ + printf("fcntl=%d\n",fcntl(fd, F_SETFL,0)); + } + //测试是否为终端设备 + if(0 == isatty(fd)){ + printf("standard input is not a terminal device\n"); + return(FALSE); + } else{ + printf("isatty success!\n"); + } + printf("fd->open=%d\n",fd); + return fd; +} + +//fd串口号；speed传输波特率；databits数据位；flow_ctrl数据流；parity奇偶校验；stopbits停止位 +int serial_Set(int fd,int speed,int flow_ctrl,int databits,int stopbits,int parity) +{ + + int i; + int speed_arr[] = { B115200, B19200, B9600, B4800, B2400, B1200, B300}; + int name_arr[] = {115200, 19200, 9600, 4800, 2400, 1200, 300}; + + struct termios options; + + /*tcgetattr(fd,&options)得到与fd指向对象的相关参数，并将它们保存于options,该函数还可以测试配置是否正确，该串口是否可用等。若调用成功，函数返回值为0，若调用失败，函数返回值为1. + */ + if ( tcgetattr( fd,&options) != 0) { + perror("SetupSerial 1"); + return(FALSE); + } + + //设置串口输入波特率和输出波特率 + for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++) { + if (speed == name_arr[i]) { + cfsetispeed(&options, speed_arr[i]); + cfsetospeed(&options, speed_arr[i]); + } + } + + //修改控制模式，保证程序不会占用串口 + options.c_cflag |= CLOCAL; + //修改控制模式，使得能够从串口中读取输入数据 + options.c_cflag |= CREAD; + options.c_oflag &= ~(ONLCR | OCRNL); + options.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); + options.c_iflag &= ~(ICRNL | INLCR); + options.c_iflag &= ~(IXON | IXOFF | IXANY); + + //设置数据流控制 + switch(flow_ctrl) { + + case 0 ://不使用流控制 + options.c_cflag &= ~CRTSCTS; + break; + case 1 ://使用硬件流控制 + options.c_cflag |= CRTSCTS; + break; + case 2 ://使用软件流控制 + options.c_cflag |= IXON | IXOFF | IXANY; + break; + } + //设置数据位 + //屏蔽其他标志位 + options.c_cflag &= ~CSIZE; + switch (databits) { + case 5 : + options.c_cflag |= CS5; + break; + case 6 : + options.c_cflag |= CS6; + break; + case 7 : + options.c_cflag |= CS7; + break; + case 8: + options.c_cflag |= CS8; + break; + default: + fprintf(stderr,"Unsupported data size\n"); + return (FALSE); + } + //设置校验位 + switch (parity) { + case 'n': + case 'N': //无奇偶校验位。 + options.c_cflag &= ~PARENB; + options.c_iflag &= ~INPCK; + break; + case 'o': + case 'O'://设置为奇校验 + options.c_cflag |= (PARODD | PARENB); + options.c_iflag |= INPCK; + break; + case 'e': + case 'E'://设置为偶校验 + options.c_cflag |= PARENB; + options.c_cflag &= ~PARODD; + options.c_iflag |= INPCK; + break; + case 's': + case 'S': //设置为空格 + options.c_cflag &= ~PARENB; + options.c_cflag &= ~CSTOPB; + break; + default: + fprintf(stderr,"Unsupported parity\n"); + return (FALSE); + } + // 设置停止位 + switch (stopbits) { + case 1: + options.c_cflag &= ~CSTOPB; + break; + case 2: + options.c_cflag |= CSTOPB; + break; + default: + fprintf(stderr,"Unsupported stop bits\n"); + return (FALSE); + } + + //修改输出模式，原始数据输出 + options.c_oflag &= ~OPOST; + options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);//我加的 + //options.c_lflag &= ~(ISIG | ICANON); + + //设置等待时间和最小接收字符 + options.c_cc[VTIME] = 1; /* 读取一个字符等待0*(0/10)s */ + options.c_cc[VMIN] = 1; /* 读取字符的最少个数为0 */ + + //如果发生数据溢出，接收数据，但是不再读取 刷新收到的数据但是不读 + tcflush(fd,TCIFLUSH); + + //激活配置 (将修改后的termios数据设置到串口中） + if (tcsetattr(fd,TCSANOW,&options) != 0) { + perror("com set error!\n"); + return (FALSE); + } + printf("serial set success\n"); + return (TRUE); +} + +int serial_init(char *devpath) +{ + int fd_comport = FALSE; + //打开串口 + if((fd_comport=serial_open(devpath))<0){ + perror("serial_Open"); + return FALSE; + } + //设置串口数据帧格式 + if (serial_Set(fd_comport,115200,0,8,1,'N')<0) { + perror("serial_Set"); + return FALSE; + } + return fd_comport; +} + +ssize_t serial_recv_exact_nbytes(int fd, void *buf, size_t count) +{ + ssize_t ret; + ssize_t total = 0; + unsigned char * buf1 = (unsigned char *)buf; + assert(buf != NULL); + + while (total != count) { + fprintf(stdout,"%d\n",fd); + fprintf(stdout,"hi..\n"); + ret = read(fd, buf + total, count - total); + int i = 0; + for (i = 0; i < 36; i++){ + printf("%.2x ", buf1[i]); + } + fprintf(stdout,"hi2\n"); + if (ret == -1) { + perror("serial->recv"); + break; + } else if (ret == 0) { + fprintf(stdout, "serial->recv: timeout or end-of-file\n"); + break; + } else + total += ret; + } + + return total; +} + +ssize_t serial_send_exact_nbytes(int fd, unsigned char *buf, size_t count) +{ + ssize_t ret; + ssize_t total = 0; + + assert(buf != NULL); + int i = 0; + for (i = 0; i < 36; i++){ + printf("%.2x ", buf[i]); + } + printf("\n"); + while (total != count) { + ret = write(fd, buf + total, count - total); + fprintf(stdout,"%d\n",ret); + if (ret == -1) { + perror("serial->send"); + break; + } else + total += ret; + } + + return total; +} + +int serial_exit(int fd) +{ + if (close(fd)) { + perror("serial->exit"); + return -1; + } + + return 0; +} diff --git a/smart_home_server/server.c b/smart_home_server/server.c new file mode 100755 index 0000000..14a7786 --- /dev/null +++ b/smart_home_server/server.c @@ -0,0 +1,312 @@ +/************************************************************************* + > File Name: server.c + > Author: lei + > Mail: + > Created Time: Wed 29 Aug 2018 11:44:14 AM CST + ************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "./include/server.h" +#include "./include/modul.h" +#include "./include/shm.h" +#include "./include/serial.h" + +#define SPORT 7777 +#define LISNUM 1024 +#define BUFFER_SIZE 128 +char env_buf[128]; +char cmd_buf[5]; +char *p_shm = NULL; + +void read_env(int signo) +{ + read_shm(p_shm,env_buf,sizeof(env_char_data)); +} + +int A9_process() +{ + int i = 0; + char led1,led2,fan; + int socketId,connfd = 0; + int ret = 0; + int recv_len = 0; + struct sockaddr_in serveraddr,clientaddr; + socklen_t server_len,client_len; + + char *buf_ope = NULL; + char *s = "//"; + char cmd[BUFFER_SIZE] = {0}; + pid_t pid,pid_zigbee; + int signo = 0; + //客户端阈值存放 + float value[8] = {0}; + + char *pPath = NULL; + struct sqlite3 *pdb = NULL; + char dbName[] = "/mysqlite"; + char tabname1[] = "data"; + char tabname2[] = "param"; + //获取pPath + pPath = getPath(dbName); + //open or create db + pdb = SqlOpen(pPath); + SqlCreatTable(pdb,tabname1); + SqlCreatTable1(pdb,tabname2); + + //创建zigbee进程 + pid_zigbee = fork(); + if(pid_zigbee < 0) + { + perror("zigbee process fail!"); + return -1; + } + if (pid_zigbee == 0) + { + int i = 0; + char buf[1] = {'\0'}; + AA: zgbfd = serial_init("/dev/ttyUSB0"); + if (zgbfd == -1) + { + sleep(1); + goto AA; + } + else + fprintf(stdout, "init zigbee success\n"); + + //创建共享内存 + p_shm = create_shm(); + while(1) + { + send_cmd_m0(signo); + ret = zigbee_get_dat(zgbfd); + if(ret < 0) + { + perror("env_recv:"); + } + SqlInsert(pdb,tabname1,data.tem,data.hum,data.light,0); + //sqlSelected(tabname1,pdb); + //写入共享内存 + write_shm(p_shm,&env_char_data,sizeof(env_char_data)); + signal(SIGUSR2,read_env); + sleep(2); + } + } + //建立socket连接 + socketId = socket(AF_INET,SOCK_STREAM,0); + if(socketId < 0) + { + perror("create socket error"); + return -1; + } + printf("create socket succeed!\r\n"); + + //设置sockaddr_in结构体的相关参数 + server_len = sizeof(struct sockaddr_in); + memset(&serveraddr,0,server_len); + serveraddr.sin_family = AF_INET; + serveraddr.sin_port = htons(SPORT); + serveraddr.sin_addr.s_addr = INADDR_ANY; + + //绑定 + ret = bind(socketId,(struct sockaddr *)&serveraddr,server_len); + if(ret < 0) + { + perror("bind error"); + return -1; + } + printf("bind succeed!\r\n"); + + //建立监听队列 + ret = listen(socketId,LISNUM); + if(ret < 0) + { + perror("listen error"); + return -1; + } + printf("listen succeed!\r\n"); + + //等待客户端的连接(并发服务器) + client_len = sizeof(clientaddr); + memset(&clientaddr,0,client_len); + signal(SIGCHLD,SIG_IGN); + while(1) + { + connfd = accept(socketId,(struct sockaddr *)&clientaddr,&client_len); + if(connfd < 0) + { + perror("connected error"); + return -1; + } + printf("connected succeed!\r\n"); + + + //通信 + pid = fork(); + if(pid < 0) + { + perror("create process error"); + return -1; + } + if(pid == 0) + { + recv_len = recv(connfd,cmd,BUFFER_SIZE,0); + while(recv_len > 0) + { + //查询历史数据 + if(0 == strncmp(cmd,"SearchHistoryData",17)) + { + //p_shm = create_shm(); + //write_shm(p_shm,str,sizeof(str)); + printf("cmd = %s\r\n",cmd); + send(connfd,cmd,sizeof(cmd),0); + } + + //设置安全阈值 + else if(0 == strncmp(cmd,"SetSecureValue:",15)) + { + p_shm = create_shm(); + read_env(signo); + + for(i = 0; i < 5; i++) + { + printf("buf = %d\r\n",env_buf[i]); + } + memset(value,0,sizeof(value) / sizeof(value[0])); + buf_ope = strtok(cmd+15,s); + while(buf_ope != NULL) + { + value[i] = atof(buf_ope); + printf("value = %.2f\r\n",value[i]); + i++; + buf_ope = strtok(NULL,s); + } + //将阈值插入到数据库 + SqlInsert1(pdb,tabname2,*value,*(value+1),*(value+2),*(value+3),*(value+4),*(value+5),*(value+6),*(value+7)); + sqlSelected(tabname2,pdb); + if(recv_len > 0) + { + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"SetSecureValue:succeed",23); + send(connfd,cmd,sizeof(cmd),0); + } + } + + //解析到是主界面 + /*else if(strncmp(cmd,"ThisIsWidget",12)) + { + p_shm = create_shm(); + read_env(signo); + + for(i = 0; i < 5; i++) + { + printf("buf = %d\r\n",env_buf[i]); + } + printf("cmd = %s\r\n",cmd); + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"Main_Theme",10); + send(connfd,cmd,sizeof(cmd),0); + printf("widget\n"); + }*/ + + //解析客厅灯 + else if(0 == strncmp(cmd,"Livingroom:ON",13)) + { + p_shm = create_shm(); + printf("cmd = %s\r\n",cmd); + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"Livingroom:open",15); + send(connfd,cmd,sizeof(cmd),0); + led1 = 1; + write_shm(p_shm+11,&led1,1); + signal(SIGUSR1,send_cmd_m0); + } + + + else if(0 == strncmp(cmd,"Livingroom:OFF",14)) + { + p_shm = create_shm(); + printf("cmd = %s\r\n",cmd); + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"Livingroom:close",16); + send(connfd,cmd,sizeof(cmd),0); + led1 = 0; + write_shm(p_shm+11,&led1,1); + //printf("p_shm+11 = %d\r\n",p_shm[11]); + signal(SIGUSR1,send_cmd_m0); + } + + //解析卧室灯 + else if(0 == strncmp(cmd,"Bedroom:ON",10)) + { + p_shm = create_shm(); + printf("cmd = %s\r\n",cmd); + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"Bedroom:ON",10); + send(connfd,cmd,sizeof(cmd),0); + led2 = 1; + write_shm(p_shm+12,&led2,1); + //printf("p_shm+12 = %d\r\n",p_shm[12]); + signal(SIGUSR1,send_cmd_m0); + } + + else if(0 == strncmp(cmd,"Bedroom:OFF",11)) + { + p_shm = create_shm(); + printf("cmd = %s\r\n",cmd); + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"Bedroom:close",13); + send(connfd,cmd,sizeof(cmd),0); + led2 = 0; + write_shm(p_shm+12,&led2,1); + signal(SIGUSR1,send_cmd_m0); + } + + //解析空调 + else if(0 == strncmp(cmd,"Aircondition:ON",15)) + { + p_shm = create_shm(); + printf("cmd = %s\r\n",cmd); + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"Aircondition:open",17); + send(connfd,cmd,sizeof(cmd),0); + fan = 1; + write_shm(p_shm+13,&fan,1); + signal(SIGUSR1,send_cmd_m0); + } + + else if(0 == strncmp(cmd,"Aircondition:OFF",16)) + { + p_shm = create_shm(); + printf("cmd = %s\r\n",cmd); + memset(cmd,0,sizeof(cmd)); + strncpy(cmd,"Aircondition:close",18); + send(connfd,cmd,sizeof(cmd),0); + fan = 0; + write_shm(p_shm+13,&fan,1); + signal(SIGUSR1,send_cmd_m0); + } + recv_len = recv(connfd,cmd,BUFFER_SIZE,0); + } + } + //关闭连接 + close(connfd); + } + + //关闭socket + close(socketId); + free(pPath); + pPath = NULL; + pdb = NULL; + return 0; +} diff --git a/smart_home_server/shm.c b/smart_home_server/shm.c new file mode 100755 index 0000000..a866300 --- /dev/null +++ b/smart_home_server/shm.c @@ -0,0 +1,51 @@ +#include "./include/shm.h" +int shmid = 0; +key_t key = 0; +//创建共享内存 +char *create_shm() +{ + key = ftok(PATH, 123); + printf("key = %p\r\n",key); + if (key < 0) + { + perror("ftok error"); + } + //创建或者打开共享内存 + shmid = shmget(key, SIZE, IPC_CREAT | 0666); + if (shmid < 0) + { + perror("shmget error"); + } + //映射 + char *p_shm = shmat(shmid, NULL, 0); + printf("shm = %p\r\n",p_shm); + if (NULL == p_shm) + { + perror("shmat error"); + shmctl(shmid, IPC_RMID, NULL); + } + return p_shm; +} + +//读共享内存数据 +void read_shm(char *shm,void *env, int len) +{ + printf("read succeed\r\n"); + memcpy(env,shm,len); +} + +//写入数据到共享内存 +void write_shm(char *shm,void *env, int len) +{ + printf("write succeed\r\n"); + memcpy(shm,env,len); +} + +//解除映射 +void delete_shm(char *p_shm) +{ + shmdt(p_shm); + p_shm = NULL; + //删除共享内存 + shmctl(shmid, IPC_RMID, NULL); +} diff --git a/smart_home_server/sqlite.c b/smart_home_server/sqlite.c new file mode 100755 index 0000000..1961311 --- /dev/null +++ b/smart_home_server/sqlite.c @@ -0,0 +1,277 @@ +#include "./include/server.h" +char databuf[72][25]; +char *pErrMsg = NULL; +int dataline = 0; +#define FILEPATH_MAX (80) +#define Line_Max 12 +void sqlDelete(char * tabname,struct sqlite3 *pdb,int templine); +char * getPath(char *dbName) +{ + char *pPath = NULL; + pPath = (char *) malloc (FILEPATH_MAX + 10); + if (NULL == pPath) + { + //return -1; + } + memset(pPath, 0, FILEPATH_MAX + 10); + /*if (NULL == getcwd(pPath, FILEPATH_MAX)) + { + // return -1; + }*/ + printf("%s %d\n",pPath,strlen(pPath)); + memcpy(pPath + strlen(pPath), dbName, strlen(dbName)); + printf("%s %d\n",pPath,strlen(pPath)); + /*db name end*/ + return pPath; +} + +struct sqlite3 * SqlOpen(char* pPath) +{ + struct sqlite3 *pdb; + //open or create db + int iResult = sqlite3_open((const char *)pPath,&pdb); + if(SQLITE_OK != iResult || NULL == pdb) + { + printf("invoke sqlite3_open function error!\n"); + free(pPath); + pPath = NULL; + //return -1; + } + printf("open sqlite succeed\r\n"); + return pdb; +} + +//求行数 +int sqlCount(struct sqlite3 *pdb,char *tabname ) +{ + char** ppTable = NULL; + int iRow = 0; + int iColumn = 0; + + char sqlCount1[1024] ={0}; + sprintf(sqlCount1,"select * from %s",tabname); + int iResult = sqlite3_get_table(pdb, sqlCount1, &ppTable, &iRow, &iColumn,&pErrMsg); + printf("%d\n",iRow); + return iRow; +} + + +/* +tabname//表名 +//如果总计数行大于5,顺序删除表的每一行然后重新插入 + +*/ +void SqlInsert1(struct sqlite3 *pdb,char *tabname,float tempMax,float tempMin,float humMax,float humMin,float luxMax, float luxMin,float ppmMax,float ppmMin ) +{ + //insert table + //int templine = 0; + // templine = dataline; + char sqlInsert1[1024] = {0}; + + //UPDATE tabneme SET ADDRESS = 'Texas' WHERE ID = 6; + sprintf(sqlInsert1, "insert into %s (TempMax,TempMin,HumMax,HumMin,LuxMax,LuxMin,PpmMax,PpmMin) values (%5f,%5f,%5f,%5f,%5f,%5f,%5f,%5f)",tabname,tempMax,tempMin,humMax,humMin,luxMax,luxMin,ppmMax,ppmMin); + int iResult = sqlite3_exec(pdb, sqlInsert1, 0, 0, &pErrMsg); + if(SQLITE_OK != iResult) + { + // printf("%s\n", pErrMsg); + //sqlite3_free(pErrMsg); + } + sqlite3_free(pErrMsg); + +} + +/* +tabname//表名 +//如果总计数行大于5,顺序删除表的每一行然后重新插入 +*/ +void SqlInsert(struct sqlite3 *pdb,char *tabname,float temp,float hum,float lux ,float ppm ) +{ + //insert table + int templine = 0; + templine = dataline; + char sqlInsert[1024] = {0}; + + templine %= Line_Max; + //删除对应行 + if(dataline >= Line_Max) + { + //删除哪张表的哪一行 + sqlDelete(tabname,pdb,templine); + } + //UPDATE tabneme SET ADDRESS = 'Texas' WHERE ID = 6; + sprintf(sqlInsert, "insert into %s (_ID,Temp1,Hum,Lux,Ppm) values (%d,%5f,%5f,%5f,%5f)",tabname,templine,temp,hum,lux,ppm); + int iResult = sqlite3_exec(pdb, sqlInsert, 0, 0, &pErrMsg); + if(SQLITE_OK != iResult) + { + // printf("%s\n", pErrMsg); + //sqlite3_free(pErrMsg); + } + sqlite3_free(pErrMsg); + //总计数++ + dataline ++; +} + +//创建表数据 +// +void SqlCreatTable(struct sqlite3 *pdb,char* tabname) +{ + + /*CREATE TABLE env1(_ID INTEGER PRIMARY KEY, name VARCHAR (50),time1 TimeStamp NOT NULL DEFAULT (datetime('now','localtime')));*/ + char sqlCreateTable[1024] = {0}; + sprintf(sqlCreateTable, "create table if not exists %s(_ID integer primary key,Data TimeStamp NOT NULL DEFAULT (datetime('now','localtime')),Temp1 real,Hum real,Lux real,Ppm real)",tabname); + int iResult = sqlite3_exec(pdb, sqlCreateTable, 0, 0, &pErrMsg); + if(SQLITE_OK != iResult) + { + printf("%s\n", pErrMsg); + //sqlite3_free(pErrMsg); + } + printf("create %s succeed\r\n",tabname); + sqlite3_free(pErrMsg); +} + +//创建表参数阈值 +// +void SqlCreatTable1(struct sqlite3 *pdb,char* tabname) +{ + + /*CREATE TABLE env1(_ID INTEGER PRIMARY KEY, name VARCHAR (50),time1 TimeStamp NOT NULL DEFAULT (datetime('now','localtime')));*/ + char sqlCreateTable1[1024] = {0}; + sprintf(sqlCreateTable1, "create table if not exists %s(_ID integer primary key,Data TimeStamp NOT NULL DEFAULT (datetime('now','localtime')),TempMax real,TempMin real,HumMax real,HumMin real,LuxMax real,LuxMin real,PpmMax real,PpmMin real)",tabname); + int iResult = sqlite3_exec(pdb, sqlCreateTable1, 0, 0, &pErrMsg); + if(SQLITE_OK != iResult) + { + printf("%s\n", pErrMsg); + //sqlite3_free(pErrMsg); + } + printf("create %s succeed\r\n",tabname); + sqlite3_free(pErrMsg); +} + +//select table +int sqlSelected(char * tabname,struct sqlite3 *pdb) +{ + char** ppTable = NULL; + int iRow = 0; + int iColumn = 0; + int count = 0; + char sqlSelect[1024] ={0}; + sprintf(sqlSelect,"select * from %s",tabname); + int iResult = sqlite3_get_table(pdb, sqlSelect, &ppTable, &iRow, &iColumn,&pErrMsg); + + if (SQLITE_OK != iResult) + { + printf("%s\n", pErrMsg); + } + sqlite3_free(pErrMsg); + //显示 + count = iRow; + printf("select sql row %d column %d\n", iRow, iColumn); + if (NULL != ppTable) + { + int i = 1; + for (; i <= iRow; i++) + { + int j = 0; + for (; j < iColumn; j++) + { + if (NULL != ppTable[i * iColumn + j]) + { + fprintf(stdout,"%s ",ppTable[i * iColumn + j]); + } + + } + printf("\n"); + } + } + sqlite3_free_table(ppTable); + return count; +} + +void if_tabExit(char* tabname,struct sqlite3 *pdb) +{ + char tabExit[1024] = {0}; + + sprintf(tabExit,"drop table if exists %s",tabname); + int iResult = sqlite3_exec(pdb, tabExit, 0, 0, &pErrMsg); + if(SQLITE_OK != iResult) + { + printf("%s\n", pErrMsg); + //sqlite3_free(pErrMsg); + } + sqlite3_free(pErrMsg); +} + +//删除行 +void sqlDelete(char * tabname,struct sqlite3 *pdb,int templine) +{ + char sqlDelete1[1024] = {0}; + // DELETE FROM env1 WHERE _ID = 1; + sprintf(sqlDelete1," delete from %s where _ID = %d",tabname,templine); + int iResult = sqlite3_exec(pdb, sqlDelete1, 0, 0, &pErrMsg); + if(SQLITE_OK != iResult) + { + printf("%s\n", pErrMsg); + //sqlite3_free(pErrMsg); + } + sqlite3_free(pErrMsg); +} + + +//获取所有数据 +int sqlGetData(char * tabname,struct sqlite3 *pdb) +{ + //char databuf[72][25]; + int i = 0; + char** ppTable = NULL; + int iRow = 0; + int iColumn = 0; + int count = 0; + char sqlGetData1[1024] ={0}; + sprintf(sqlGetData1,"select * from %s",tabname); + int iResult = sqlite3_get_table(pdb, sqlGetData1, &ppTable, &iRow, &iColumn,&pErrMsg); + + if (SQLITE_OK != iResult) + { + printf("%s\n", pErrMsg); + } + sqlite3_free(pErrMsg); + //显示 + // count = iRow; + // printf("select sql row %d column %d\n", iRow, iColumn); + for(i = 0; i< 72;i++) + { + + memset(databuf[i],0,strlen(databuf[i])); + } + // memset(databuf,0,strlen(databuf)); + if (NULL != ppTable) + { + int i = 1; + for (; i <= iRow; i++) + { + int j = 0; + for (; j < iColumn; j++) + { + if (NULL != ppTable[i * iColumn + j]) + { + //printf("%s ",ppTable[i * iColumn + j]); + strcpy(databuf[i*iColumn+j],ppTable[i*iColumn+j]); + // databuf[i*iColumn +j] = ppTable[i * iColumn + j]; + } + + } + printf("\n"); + } + } + sqlite3_free_table(ppTable); + return count; +} + +void show() +{ + int i = 0; + for(i= 0;i< 72; i++) + { + printf("%s \n",databuf[i]); + } +} diff --git a/smart_home_server/sqlite3.c b/smart_home_server/sqlite3.c new file mode 100755 index 0000000..37ee4ad --- /dev/null +++ b/smart_home_server/sqlite3.c @@ -0,0 +1,138114 @@ +/****************************************************************************** +** This file is an amalgamation of many separate C source files from SQLite +** version 3.7.16.1. By combining all the individual C code files into this +** single large file, the entire code can be compiled as a single translation +** unit. This allows many compilers to do optimizations that would not be +** possible if the files were compiled separately. Performance improvements +** of 5% or more are commonly seen when SQLite is compiled as a single +** translation unit. +** +** This file is all you need to compile SQLite. To use SQLite in other +** programs, you need this file and the "sqlite3.h" header file that defines +** the programming interface to the SQLite library. (If you do not have +** the "sqlite3.h" header file at hand, you will find a copy embedded within +** the text of this file. Search for "Begin file sqlite3.h" to find the start +** of the embedded sqlite3.h header file.) Additional code files may be needed +** if you want a wrapper to interface SQLite with your choice of programming +** language. The code for the "sqlite3" command-line shell is also in a +** separate file. This file contains only code for the core SQLite library. +*/ +#define SQLITE_CORE 1 +#define SQLITE_AMALGAMATION 1 +#ifndef SQLITE_PRIVATE +# define SQLITE_PRIVATE static +#endif +#ifndef SQLITE_API +# define SQLITE_API +#endif +/************** Begin file sqliteInt.h ***************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** Internal interface definitions for SQLite. +** +*/ +#ifndef _SQLITEINT_H_ +#define _SQLITEINT_H_ + +/* +** These #defines should enable >2GB file support on POSIX if the +** underlying operating system supports it. If the OS lacks +** large file support, or if the OS is windows, these should be no-ops. +** +** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any +** system #includes. Hence, this block of code must be the very first +** code in all source files. +** +** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch +** on the compiler command line. This is necessary if you are compiling +** on a recent machine (ex: Red Hat 7.2) but you want your code to work +** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2 +** without this option, LFS is enable. But LFS does not exist in the kernel +** in Red Hat 6.0, so the code won't work. Hence, for maximum binary +** portability you should omit LFS. +** +** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + +/* +** Include the configuration header output by 'configure' if we're using the +** autoconf-based build +*/ +#ifdef _HAVE_SQLITE_CONFIG_H +#include "config.h" +#endif + +/************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/ +/************** Begin file sqliteLimit.h *************************************/ +/* +** 2007 May 7 +** +** 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 defines various limits of what SQLite can process. +*/ + +/* +** The maximum length of a TEXT or BLOB in bytes. This also +** limits the size of a row in a table or index. +** +** The hard limit is the ability of a 32-bit signed integer +** to count the size: 2^31-1 or 2147483647. +*/ +#ifndef SQLITE_MAX_LENGTH +# define SQLITE_MAX_LENGTH 1000000000 +#endif + +/* +** This is the maximum number of +** +** * Columns in a table +** * Columns in an index +** * Columns in a view +** * Terms in the SET clause of an UPDATE statement +** * Terms in the result set of a SELECT statement +** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement. +** * Terms in the VALUES clause of an INSERT statement +** +** The hard upper limit here is 32676. Most database people will +** tell you that in a well-normalized database, you usually should +** not have more than a dozen or so columns in any table. And if +** that is the case, there is no point in having more than a few +** dozen values in any of the other situations described above. +*/ +#ifndef SQLITE_MAX_COLUMN +# define SQLITE_MAX_COLUMN 2000 +#endif + +/* +** The maximum length of a single SQL statement in bytes. +** +** It used to be the case that setting this value to zero would +** turn the limit off. That is no longer true. It is not possible +** to turn this limit off. +*/ +#ifndef SQLITE_MAX_SQL_LENGTH +# define SQLITE_MAX_SQL_LENGTH 1000000000 +#endif + +/* +** The maximum depth of an expression tree. This is limited to +** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might +** want to place more severe limits on the complexity of an +** expression. +** +** A value of 0 used to mean that the limit was not enforced. +** But that is no longer true. The limit is now strictly enforced +** at all times. +*/ +#ifndef SQLITE_MAX_EXPR_DEPTH +# define SQLITE_MAX_EXPR_DEPTH 1000 +#endif + +/* +** The maximum number of terms in a compound SELECT statement. +** The code generator for compound SELECT statements does one +** level of recursion for each term. A stack overflow can result +** if the number of terms is too large. In practice, most SQL +** never has more than 3 or 4 terms. Use a value of 0 to disable +** any limit on the number of terms in a compount SELECT. +*/ +#ifndef SQLITE_MAX_COMPOUND_SELECT +# define SQLITE_MAX_COMPOUND_SELECT 500 +#endif + +/* +** The maximum number of opcodes in a VDBE program. +** Not currently enforced. +*/ +#ifndef SQLITE_MAX_VDBE_OP +# define SQLITE_MAX_VDBE_OP 25000 +#endif + +/* +** The maximum number of arguments to an SQL function. +*/ +#ifndef SQLITE_MAX_FUNCTION_ARG +# define SQLITE_MAX_FUNCTION_ARG 127 +#endif + +/* +** The maximum number of in-memory pages to use for the main database +** table and for temporary tables. The SQLITE_DEFAULT_CACHE_SIZE +*/ +#ifndef SQLITE_DEFAULT_CACHE_SIZE +# define SQLITE_DEFAULT_CACHE_SIZE 2000 +#endif +#ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE +# define SQLITE_DEFAULT_TEMP_CACHE_SIZE 500 +#endif + +/* +** The default number of frames to accumulate in the log file before +** checkpointing the database in WAL mode. +*/ +#ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT +# define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000 +#endif + +/* +** The maximum number of attached databases. This must be between 0 +** and 62. The upper bound on 62 is because a 64-bit integer bitmap +** is used internally to track attached databases. +*/ +#ifndef SQLITE_MAX_ATTACHED +# define SQLITE_MAX_ATTACHED 10 +#endif + + +/* +** The maximum value of a ?nnn wildcard that the parser will accept. +*/ +#ifndef SQLITE_MAX_VARIABLE_NUMBER +# define SQLITE_MAX_VARIABLE_NUMBER 999 +#endif + +/* Maximum page size. The upper bound on this value is 65536. This a limit +** imposed by the use of 16-bit offsets within each page. +** +** Earlier versions of SQLite allowed the user to change this value at +** compile time. This is no longer permitted, on the grounds that it creates +** a library that is technically incompatible with an SQLite library +** compiled with a different limit. If a process operating on a database +** with a page-size of 65536 bytes crashes, then an instance of SQLite +** compiled with the default page-size limit will not be able to rollback +** the aborted transaction. This could lead to database corruption. +*/ +#ifdef SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_PAGE_SIZE +#endif +#define SQLITE_MAX_PAGE_SIZE 65536 + + +/* +** The default size of a database page. +*/ +#ifndef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE 1024 +#endif +#if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_DEFAULT_PAGE_SIZE +# define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + +/* +** Ordinarily, if no value is explicitly provided, SQLite creates databases +** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain +** device characteristics (sector-size and atomic write() support), +** SQLite may choose a larger value. This constant is the maximum value +** SQLite will choose on its own. +*/ +#ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 +#endif +#if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE +# undef SQLITE_MAX_DEFAULT_PAGE_SIZE +# define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE +#endif + + +/* +** Maximum number of pages in one database file. +** +** This is really just the default value for the max_page_count pragma. +** This value can be lowered (or raised) at run-time using that the +** max_page_count macro. +*/ +#ifndef SQLITE_MAX_PAGE_COUNT +# define SQLITE_MAX_PAGE_COUNT 1073741823 +#endif + +/* +** Maximum length (in bytes) of the pattern in a LIKE or GLOB +** operator. +*/ +#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH +# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 +#endif + +/* +** Maximum depth of recursion for triggers. +** +** A value of 1 means that a trigger program will not be able to itself +** fire any triggers. A value of 0 means that no trigger programs at all +** may be executed. +*/ +#ifndef SQLITE_MAX_TRIGGER_DEPTH +# define SQLITE_MAX_TRIGGER_DEPTH 1000 +#endif + +/************** End of sqliteLimit.h *****************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/* Disable nuisance warnings on Borland compilers */ +#if defined(__BORLANDC__) +#pragma warn -rch /* unreachable code */ +#pragma warn -ccc /* Condition is always true or false */ +#pragma warn -aus /* Assigned value is never used */ +#pragma warn -csu /* Comparing signed and unsigned */ +#pragma warn -spa /* Suspicious pointer arithmetic */ +#endif + +/* Needed for various definitions... */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +#if defined(__OpenBSD__) && !defined(_BSD_SOURCE) +# define _BSD_SOURCE +#endif + +/* +** Include standard header files as necessary +*/ +#ifdef HAVE_STDINT_H +#include +#endif +#ifdef HAVE_INTTYPES_H +#include +#endif + +/* +** The following macros are used to cast pointers to integers and +** integers to pointers. The way you do this varies from one compiler +** to the next, so we have developed the following set of #if statements +** to generate appropriate macros for a wide range of compilers. +** +** The correct "ANSI" way to do this is to use the intptr_t type. +** Unfortunately, that typedef is not available on all compilers, or +** if it is available, it requires an #include of specific headers +** that vary from one machine to the next. +** +** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on +** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)). +** So we have to define the macros in different ways depending on the +** compiler. +*/ +#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */ +# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) +#elif !defined(__GNUC__) /* Works for compilers other than LLVM */ +# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) +# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) +#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */ +# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) +#else /* Generates a warning - but it always works */ +# define SQLITE_INT_TO_PTR(X) ((void*)(X)) +# define SQLITE_PTR_TO_INT(X) ((int)(X)) +#endif + +/* +** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2. +** 0 means mutexes are permanently disable and the library is never +** threadsafe. 1 means the library is serialized which is the highest +** level of threadsafety. 2 means the libary is multithreaded - multiple +** threads can use SQLite as long as no two threads try to use the same +** database connection at the same time. +** +** Older versions of SQLite used an optional THREADSAFE macro. +** We support that for legacy. +*/ +#if !defined(SQLITE_THREADSAFE) +#if defined(THREADSAFE) +# define SQLITE_THREADSAFE THREADSAFE +#else +# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */ +#endif +#endif + +/* +** Powersafe overwrite is on by default. But can be turned off using +** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option. +*/ +#ifndef SQLITE_POWERSAFE_OVERWRITE +# define SQLITE_POWERSAFE_OVERWRITE 1 +#endif + +/* +** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1. +** It determines whether or not the features related to +** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can +** be overridden at runtime using the sqlite3_config() API. +*/ +#if !defined(SQLITE_DEFAULT_MEMSTATUS) +# define SQLITE_DEFAULT_MEMSTATUS 1 +#endif + +/* +** Exactly one of the following macros must be defined in order to +** specify which memory allocation subsystem to use. +** +** SQLITE_SYSTEM_MALLOC // Use normal system malloc() +** SQLITE_WIN32_MALLOC // Use Win32 native heap API +** SQLITE_ZERO_MALLOC // Use a stub allocator that always fails +** SQLITE_MEMDEBUG // Debugging version of system malloc() +** +** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the +** assert() macro is enabled, each call into the Win32 native heap subsystem +** will cause HeapValidate to be called. If heap validation should fail, an +** assertion will be triggered. +** +** (Historical note: There used to be several other options, but we've +** pared it down to just these three.) +** +** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as +** the default. +*/ +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)>1 +# error "Two or more of the following compile-time configuration options\ + are defined but at most one is allowed:\ + SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\ + SQLITE_ZERO_MALLOC" +#endif +#if defined(SQLITE_SYSTEM_MALLOC) \ + + defined(SQLITE_WIN32_MALLOC) \ + + defined(SQLITE_ZERO_MALLOC) \ + + defined(SQLITE_MEMDEBUG)==0 +# define SQLITE_SYSTEM_MALLOC 1 +#endif + +/* +** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the +** sizes of memory allocations below this value where possible. +*/ +#if !defined(SQLITE_MALLOC_SOFT_LIMIT) +# define SQLITE_MALLOC_SOFT_LIMIT 1024 +#endif + +/* +** We need to define _XOPEN_SOURCE as follows in order to enable +** recursive mutexes on most Unix systems. But Mac OS X is different. +** The _XOPEN_SOURCE define causes problems for Mac OS X we are told, +** so it is omitted there. See ticket #2673. +** +** Later we learn that _XOPEN_SOURCE is poorly or incorrectly +** implemented on some systems. So we avoid defining it at all +** if it is already defined or if it is unneeded because we are +** not doing a threadsafe build. Ticket #2681. +** +** See also ticket #2741. +*/ +#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) \ + && !defined(__APPLE__) && SQLITE_THREADSAFE +# define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */ +#endif + +/* +** The TCL headers are only needed when compiling the TCL bindings. +*/ +#if defined(SQLITE_TCL) || defined(TCLSH) +# include +#endif + +/* +** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that +** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true, +** make it true by defining or undefining NDEBUG. +** +** Setting NDEBUG makes the code smaller and run faster by disabling the +** number assert() statements in the code. So we want the default action +** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG +** is set. Thus NDEBUG becomes an opt-in rather than an opt-out +** feature. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif +#if defined(NDEBUG) && defined(SQLITE_DEBUG) +# undef NDEBUG +#endif + +/* +** The testcase() macro is used to aid in coverage testing. When +** doing coverage testing, the condition inside the argument to +** testcase() must be evaluated both true and false in order to +** get full branch coverage. The testcase() macro is inserted +** to help ensure adequate test coverage in places where simple +** condition/decision coverage is inadequate. For example, testcase() +** can be used to make sure boundary values are tested. For +** bitmask tests, testcase() can be used to make sure each bit +** is significant and used at least once. On switch statements +** where multiple cases go to the same block of code, testcase() +** can insure that all cases are evaluated. +** +*/ +#ifdef SQLITE_COVERAGE_TEST +SQLITE_PRIVATE void sqlite3Coverage(int); +# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } +#else +# define testcase(X) +#endif + +/* +** The TESTONLY macro is used to enclose variable declarations or +** other bits of code that are needed to support the arguments +** within testcase() and assert() macros. +*/ +#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) +# define TESTONLY(X) X +#else +# define TESTONLY(X) +#endif + +/* +** Sometimes we need a small amount of code such as a variable initialization +** to setup for a later assert() statement. We do not want this code to +** appear when assert() is disabled. The following macro is therefore +** used to contain that setup code. The "VVA" acronym stands for +** "Verification, Validation, and Accreditation". In other words, the +** code within VVA_ONLY() will only run during verification processes. +*/ +#ifndef NDEBUG +# define VVA_ONLY(X) X +#else +# define VVA_ONLY(X) +#endif + +/* +** The ALWAYS and NEVER macros surround boolean expressions which +** are intended to always be true or false, respectively. Such +** expressions could be omitted from the code completely. But they +** are included in a few cases in order to enhance the resilience +** of SQLite to unexpected behavior - to make the code "self-healing" +** or "ductile" rather than being "brittle" and crashing at the first +** hint of unplanned behavior. +** +** In other words, ALWAYS and NEVER are added for defensive code. +** +** When doing coverage testing ALWAYS and NEVER are hard-coded to +** be true and false so that the unreachable code then specify will +** not be counted as untested code. +*/ +#if defined(SQLITE_COVERAGE_TEST) +# define ALWAYS(X) (1) +# define NEVER(X) (0) +#elif !defined(NDEBUG) +# define ALWAYS(X) ((X)?1:(assert(0),0)) +# define NEVER(X) ((X)?(assert(0),1):0) +#else +# define ALWAYS(X) (X) +# define NEVER(X) (X) +#endif + +/* +** Return true (non-zero) if the input is a integer that is too large +** to fit in 32-bits. This macro is used inside of various testcase() +** macros to verify that we have tested SQLite for large-file support. +*/ +#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0) + +/* +** The macro unlikely() is a hint that surrounds a boolean +** expression that is usually false. Macro likely() surrounds +** a boolean expression that is usually true. GCC is able to +** use these hints to generate better code, sometimes. +*/ +#if defined(__GNUC__) && 0 +# define likely(X) __builtin_expect((X),1) +# define unlikely(X) __builtin_expect((X),0) +#else +# define likely(X) !!(X) +# define unlikely(X) !!(X) +#endif + +/************** Include sqlite3.h in the middle of sqliteInt.h ***************/ +/************** Begin file sqlite3.h *****************************************/ +/* +** 2001 September 15 +** +** 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 header file defines the interface that the SQLite library +** presents to client programs. If a C-function, structure, datatype, +** or constant definition does not appear in this file, then it is +** not a published API of SQLite, is subject to change without +** notice, and should not be referenced by programs that use SQLite. +** +** Some of the definitions that are in this file are marked as +** "experimental". Experimental interfaces are normally new +** features recently added to SQLite. We do not anticipate changes +** to experimental interfaces but reserve the right to make minor changes +** if experience from use "in the wild" suggest such changes are prudent. +** +** The official C-language API documentation for SQLite is derived +** from comments in this file. This file is the authoritative source +** on how SQLite interfaces are suppose to operate. +** +** The name of this file under configuration management is "sqlite.h.in". +** The makefile makes some minor changes to this file (such as inserting +** the version number) and changes its name to "sqlite3.h" as +** part of the build process. +*/ +#ifndef _SQLITE3_H_ +#define _SQLITE3_H_ +#include /* Needed for the definition of va_list */ + +/* +** Make sure we can call this stuff from C++. +*/ +#if 0 +extern "C" { +#endif + + +/* +** Add the ability to override 'extern' +*/ +#ifndef SQLITE_EXTERN +# define SQLITE_EXTERN extern +#endif + +#ifndef SQLITE_API +# define SQLITE_API +#endif + + +/* +** These no-op macros are used in front of interfaces to mark those +** interfaces as either deprecated or experimental. New applications +** should not use deprecated interfaces - they are support for backwards +** compatibility only. Application writers should be aware that +** experimental interfaces are subject to change in point releases. +** +** These macros used to resolve to various kinds of compiler magic that +** would generate warning messages when they were used. But that +** compiler magic ended up generating such a flurry of bug reports +** that we have taken it all out and gone back to using simple +** noop macros. +*/ +#define SQLITE_DEPRECATED +#define SQLITE_EXPERIMENTAL + +/* +** Ensure these symbols were not defined by some previous header file. +*/ +#ifdef SQLITE_VERSION +# undef SQLITE_VERSION +#endif +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif + +/* +** CAPI3REF: Compile-Time Library Version Numbers +** +** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header +** evaluates to a string literal that is the SQLite version in the +** format "X.Y.Z" where X is the major version number (always 3 for +** SQLite3) and Y is the minor version number and Z is the release number.)^ +** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer +** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same +** numbers used in [SQLITE_VERSION].)^ +** The SQLITE_VERSION_NUMBER for any given release of SQLite will also +** be larger than the release from which it is derived. Either Y will +** be held constant and Z will be incremented or else Y will be incremented +** and Z will be reset to zero. +** +** Since version 3.6.18, SQLite source code has been stored in the +** Fossil configuration management +** system. ^The SQLITE_SOURCE_ID macro evaluates to +** a string which identifies a particular check-in of SQLite +** within its configuration management system. ^The SQLITE_SOURCE_ID +** string contains the date and time of the check-in (UTC) and an SHA1 +** hash of the entire source tree. +** +** See also: [sqlite3_libversion()], +** [sqlite3_libversion_number()], [sqlite3_sourceid()], +** [sqlite_version()] and [sqlite_source_id()]. +*/ +#define SQLITE_VERSION "3.7.16.1" +#define SQLITE_VERSION_NUMBER 3007016 +#define SQLITE_SOURCE_ID "2013-03-29 13:44:34 527231bc67285f01fb18d4451b28f61da3c4e39d" + +/* +** CAPI3REF: Run-Time Library Version Numbers +** KEYWORDS: sqlite3_version, sqlite3_sourceid +** +** These interfaces provide the same information as the [SQLITE_VERSION], +** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros +** but are associated with the library instead of the header file. ^(Cautious +** programmers might include assert() statements in their application to +** verify that values returned by these interfaces match the macros in +** the header, and thus insure that the application is +** compiled with matching library and header files. +** +**

SQLITE_CONFIG_SQLLOG +**
This option is only available if sqlite is compiled with the +** SQLITE_ENABLE_SQLLOG pre-processor macro defined. The first argument should +** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). +** The second should be of type (void*). The callback is invoked by the library +** in three separate circumstances, identified by the value passed as the +** fourth parameter. If the fourth parameter is 0, then the database connection +** passed as the second argument has just been opened. The third argument +** points to a buffer containing the name of the main database file. If the +** fourth parameter is 1, then the SQL statement that the third parameter +** points to has just been executed. Or, if the fourth parameter is 2, then +** the connection being passed as the second parameter is being closed. The +** third parameter is passed NULL In this case. +** +*/ +#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ +#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ +#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ +#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ +#define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */ +#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ +#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ +#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ +#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ +#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ +/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ +#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ +#define SQLITE_CONFIG_PCACHE 14 /* no-op */ +#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */ +#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ +#define SQLITE_CONFIG_URI 17 /* int */ +#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */ +#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */ +#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */ + +/* +** CAPI3REF: Database Connection Configuration Options +** +** These constants are the available integer configuration options that +** can be passed as the second argument to the [sqlite3_db_config()] interface. +** +** New configuration options may be added in future releases of SQLite. +** Existing configuration options might be discontinued. Applications +** should check the return code from [sqlite3_db_config()] to make sure that +** the call worked. ^The [sqlite3_db_config()] interface will return a +** non-zero [error code] if a discontinued or unsupported configuration option +** is invoked. +** +**
+**
SQLITE_DBCONFIG_LOOKASIDE
+**
^This option takes three additional arguments that determine the +** [lookaside memory allocator] configuration for the [database connection]. +** ^The first argument (the third parameter to [sqlite3_db_config()] is a +** pointer to a memory buffer to use for lookaside memory. +** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb +** may be NULL in which case SQLite will allocate the +** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the +** size of each lookaside buffer slot. ^The third argument is the number of +** slots. The size of the buffer in the first argument must be greater than +** or equal to the product of the second and third arguments. The buffer +** must be aligned to an 8-byte boundary. ^If the second argument to +** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally +** rounded down to the next smaller multiple of 8. ^(The lookaside memory +** configuration for a database connection can only be changed when that +** connection is not currently using lookaside memory, or in other words +** when the "current value" returned by +** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero. +** Any attempt to change the lookaside memory configuration when lookaside +** memory is in use leaves the configuration unchanged and returns +** [SQLITE_BUSY].)^
+** +**
SQLITE_DBCONFIG_ENABLE_FKEY
+**
^This option is used to enable or disable the enforcement of +** [foreign key constraints]. There should be two additional arguments. +** The first argument is an integer which is 0 to disable FK enforcement, +** positive to enable FK enforcement or negative to leave FK enforcement +** unchanged. The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether FK enforcement is off or on +** following this call. The second parameter may be a NULL pointer, in +** which case the FK enforcement setting is not reported back.
+** +**
SQLITE_DBCONFIG_ENABLE_TRIGGER
+**
^This option is used to enable or disable [CREATE TRIGGER | triggers]. +** There should be two additional arguments. +** The first argument is an integer which is 0 to disable triggers, +** positive to enable triggers or negative to leave the setting unchanged. +** The second parameter is a pointer to an integer into which +** is written 0 or 1 to indicate whether triggers are disabled or enabled +** following this call. The second parameter may be a NULL pointer, in +** which case the trigger setting is not reported back.
+** +**
+*/ +#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ +#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */ +#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */ + + +/* +** CAPI3REF: Enable Or Disable Extended Result Codes +** +** ^The sqlite3_extended_result_codes() routine enables or disables the +** [extended result codes] feature of SQLite. ^The extended result +** codes are disabled by default for historical compatibility. +*/ +SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** CAPI3REF: Last Insert Rowid +** +** ^Each entry in an SQLite table has a unique 64-bit signed +** integer key called the [ROWID | "rowid"]. ^The rowid is always available +** as an undeclared column named ROWID, OID, or _ROWID_ as long as those +** names are not also used by explicitly declared columns. ^If +** the table has a column of type [INTEGER PRIMARY KEY] then that column +** is another alias for the rowid. +** +** ^This routine returns the [rowid] of the most recent +** successful [INSERT] into the database from the [database connection] +** in the first argument. ^As of SQLite version 3.7.7, this routines +** records the last insert rowid of both ordinary tables and [virtual tables]. +** ^If no successful [INSERT]s +** have ever occurred on that database connection, zero is returned. +** +** ^(If an [INSERT] occurs within a trigger or within a [virtual table] +** method, then this routine will return the [rowid] of the inserted +** row as long as the trigger or virtual table method is running. +** But once the trigger or virtual table method ends, the value returned +** by this routine reverts to what it was before the trigger or virtual +** table method began.)^ +** +** ^An [INSERT] that fails due to a constraint violation is not a +** successful [INSERT] and does not change the value returned by this +** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, +** and INSERT OR ABORT make no changes to the return value of this +** routine when their insertion fails. ^(When INSERT OR REPLACE +** encounters a constraint violation, it does not fail. The +** INSERT continues to completion after deleting rows that caused +** the constraint problem so INSERT OR REPLACE will always change +** the return value of this interface.)^ +** +** ^For the purposes of this routine, an [INSERT] is considered to +** be successful even if it is subsequently rolled back. +** +** This function is accessible to SQL statements via the +** [last_insert_rowid() SQL function]. +** +** If a separate thread performs a new [INSERT] on the same +** database connection while the [sqlite3_last_insert_rowid()] +** function is running and thus changes the last insert [rowid], +** then the value returned by [sqlite3_last_insert_rowid()] is +** unpredictable and might not equal either the old or the new +** last insert [rowid]. +*/ +SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** CAPI3REF: Count The Number Of Rows Modified +** +** ^This function returns the number of database rows that were changed +** or inserted or deleted by the most recently completed SQL statement +** on the [database connection] specified by the first parameter. +** ^(Only changes that are directly specified by the [INSERT], [UPDATE], +** or [DELETE] statement are counted. Auxiliary changes caused by +** triggers or [foreign key actions] are not counted.)^ Use the +** [sqlite3_total_changes()] function to find the total number of changes +** including changes caused by triggers and foreign key actions. +** +** ^Changes to a view that are simulated by an [INSTEAD OF trigger] +** are not counted. Only real table changes are counted. +** +** ^(A "row change" is a change to a single row of a single table +** caused by an INSERT, DELETE, or UPDATE statement. Rows that +** are changed as side effects of [REPLACE] constraint resolution, +** rollback, ABORT processing, [DROP TABLE], or by any other +** mechanisms do not count as direct row changes.)^ +** +** A "trigger context" is a scope of execution that begins and +** ends with the script of a [CREATE TRIGGER | trigger]. +** Most SQL statements are +** evaluated outside of any trigger. This is the "top level" +** trigger context. If a trigger fires from the top level, a +** new trigger context is entered for the duration of that one +** trigger. Subtriggers create subcontexts for their duration. +** +** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does +** not create a new trigger context. +** +** ^This function returns the number of direct row changes in the +** most recent INSERT, UPDATE, or DELETE statement within the same +** trigger context. +** +** ^Thus, when called from the top level, this function returns the +** number of changes in the most recent INSERT, UPDATE, or DELETE +** that also occurred at the top level. ^(Within the body of a trigger, +** the sqlite3_changes() interface can be called to find the number of +** changes in the most recently completed INSERT, UPDATE, or DELETE +** statement within the body of the same trigger. +** However, the number returned does not include changes +** caused by subtriggers since those have their own context.)^ +** +** See also the [sqlite3_total_changes()] interface, the +** [count_changes pragma], and the [changes() SQL function]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_changes()] is running then the value returned +** is unpredictable and not meaningful. +*/ +SQLITE_API int sqlite3_changes(sqlite3*); + +/* +** CAPI3REF: Total Number Of Rows Modified +** +** ^This function returns the number of row changes caused by [INSERT], +** [UPDATE] or [DELETE] statements since the [database connection] was opened. +** ^(The count returned by sqlite3_total_changes() includes all changes +** from all [CREATE TRIGGER | trigger] contexts and changes made by +** [foreign key actions]. However, +** the count does not include changes used to implement [REPLACE] constraints, +** do rollbacks or ABORT processing, or [DROP TABLE] processing. The +** count does not include rows of views that fire an [INSTEAD OF trigger], +** though if the INSTEAD OF trigger makes changes of its own, those changes +** are counted.)^ +** ^The sqlite3_total_changes() function counts the changes as soon as +** the statement that makes them is completed (when the statement handle +** is passed to [sqlite3_reset()] or [sqlite3_finalize()]). +** +** See also the [sqlite3_changes()] interface, the +** [count_changes pragma], and the [total_changes() SQL function]. +** +** If a separate thread makes changes on the same database connection +** while [sqlite3_total_changes()] is running then the value +** returned is unpredictable and not meaningful. +*/ +SQLITE_API int sqlite3_total_changes(sqlite3*); + +/* +** CAPI3REF: Interrupt A Long-Running Query +** +** ^This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +** +** ^It is safe to call this routine from a thread different from the +** thread that is currently running the database operation. But it +** is not safe to call this routine with a [database connection] that +** is closed or might close before sqlite3_interrupt() returns. +** +** ^If an SQL operation is very nearly finished at the time when +** sqlite3_interrupt() is called, then it might not have an opportunity +** to be interrupted and might continue to completion. +** +** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. +** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE +** that is inside an explicit transaction, then the entire transaction +** will be rolled back automatically. +** +** ^The sqlite3_interrupt(D) call is in effect until all currently running +** SQL statements on [database connection] D complete. ^Any new SQL statements +** that are started after the sqlite3_interrupt() call and before the +** running statements reaches zero are interrupted as if they had been +** running prior to the sqlite3_interrupt() call. ^New SQL statements +** that are started after the running statement count reaches zero are +** not effected by the sqlite3_interrupt(). +** ^A call to sqlite3_interrupt(D) that occurs when there are no running +** SQL statements is a no-op and has no effect on SQL statements +** that are started after the sqlite3_interrupt() call returns. +** +** If the database connection closes while [sqlite3_interrupt()] +** is running then bad things will likely happen. +*/ +SQLITE_API void sqlite3_interrupt(sqlite3*); + +/* +** CAPI3REF: Determine If An SQL Statement Is Complete +** +** These routines are useful during command-line input to determine if the +** currently entered text seems to form a complete SQL statement or +** if additional input is needed before sending the text into +** SQLite for parsing. ^These routines return 1 if the input string +** appears to be a complete SQL statement. ^A statement is judged to be +** complete if it ends with a semicolon token and is not a prefix of a +** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within +** string literals or quoted identifier names or comments are not +** independent tokens (they are part of the token in which they are +** embedded) and thus do not count as a statement terminator. ^Whitespace +** and comments that follow the final semicolon are ignored. +** +** ^These routines return 0 if the statement is incomplete. ^If a +** memory allocation fails, then SQLITE_NOMEM is returned. +** +** ^These routines do not parse the SQL statements thus +** will not detect syntactically incorrect SQL. +** +** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior +** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked +** automatically by sqlite3_complete16(). If that initialization fails, +** then the return value from sqlite3_complete16() will be non-zero +** regardless of whether or not the input SQL is complete.)^ +** +** The input to [sqlite3_complete()] must be a zero-terminated +** UTF-8 string. +** +** The input to [sqlite3_complete16()] must be a zero-terminated +** UTF-16 string in native byte order. +*/ +SQLITE_API int sqlite3_complete(const char *sql); +SQLITE_API int sqlite3_complete16(const void *sql); + +/* +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors +** +** ^This routine sets a callback function that might be invoked whenever +** an attempt is made to open a database table that another thread +** or process has locked. +** +** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] +** is returned immediately upon encountering the lock. ^If the busy callback +** is not NULL, then the callback might be invoked with two arguments. +** +** ^The first argument to the busy handler is a copy of the void* pointer which +** is the third argument to sqlite3_busy_handler(). ^The second argument to +** the busy handler callback is the number of times that the busy handler has +** been invoked for this locking event. ^If the +** busy callback returns 0, then no additional attempts are made to +** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. +** ^If the callback returns non-zero, then another attempt +** is made to open the database for reading and the cycle repeats. +** +** The presence of a busy handler does not guarantee that it will be invoked +** when there is lock contention. ^If SQLite determines that invoking the busy +** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] +** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler. +** Consider a scenario where one process is holding a read lock that +** it is trying to promote to a reserved lock and +** a second process is holding a reserved lock that it is trying +** to promote to an exclusive lock. The first process cannot proceed +** because it is blocked by the second and the second process cannot +** proceed because it is blocked by the first. If both processes +** invoke the busy handlers, neither will make any progress. Therefore, +** SQLite returns [SQLITE_BUSY] for the first process, hoping that this +** will induce the first process to release its read lock and allow +** the second process to proceed. +** +** ^The default busy callback is NULL. +** +** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] +** when SQLite is in the middle of a large transaction where all the +** changes will not fit into the in-memory cache. SQLite will +** already hold a RESERVED lock on the database file, but it needs +** to promote this lock to EXCLUSIVE so that it can spill cache +** pages into the database file without harm to concurrent +** readers. ^If it is unable to promote the lock, then the in-memory +** cache will be left in an inconsistent state and so the error +** code is promoted from the relatively benign [SQLITE_BUSY] to +** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion +** forces an automatic rollback of the changes. See the +** +** CorruptionFollowingBusyError wiki page for a discussion of why +** this is important. +** +** ^(There can only be a single busy handler defined for each +** [database connection]. Setting a new busy handler clears any +** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] +** will also set or clear the busy handler. +** +** The busy callback should not take any actions which modify the +** database connection that invoked the busy handler. Any such actions +** result in undefined behavior. +** +** A busy handler must not close the database connection +** or [prepared statement] that invoked the busy handler. +*/ +SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); + +/* +** CAPI3REF: Set A Busy Timeout +** +** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps +** for a specified amount of time when a table is locked. ^The handler +** will sleep multiple times until at least "ms" milliseconds of sleeping +** have accumulated. ^After at least "ms" milliseconds of sleeping, +** the handler returns 0 which causes [sqlite3_step()] to return +** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. +** +** ^Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +** +** ^(There can only be a single busy handler for a particular +** [database connection] any any given moment. If another busy handler +** was defined (using [sqlite3_busy_handler()]) prior to calling +** this routine, that other busy handler is cleared.)^ +*/ +SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** CAPI3REF: Convenience Routines For Running Queries +** +** This is a legacy interface that is preserved for backwards compatibility. +** Use of this interface is not recommended. +** +** Definition: A result table is memory data structure created by the +** [sqlite3_get_table()] interface. A result table records the +** complete query results from one or more queries. +** +** The table conceptually has a number of rows and columns. But +** these numbers are not part of the result table itself. These +** numbers are obtained separately. Let N be the number of rows +** and M be the number of columns. +** +** A result table is an array of pointers to zero-terminated UTF-8 strings. +** There are (N+1)*M elements in the array. The first M pointers point +** to zero-terminated strings that contain the names of the columns. +** The remaining entries all point to query results. NULL values result +** in NULL pointers. All other values are in their UTF-8 zero-terminated +** string representation as returned by [sqlite3_column_text()]. +** +** A result table might consist of one or more memory allocations. +** It is not safe to pass a result table directly to [sqlite3_free()]. +** A result table should be deallocated using [sqlite3_free_table()]. +** +** ^(As an example of the result table format, suppose a query result +** is as follows: +** +** 
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+**
+** +** There are two column (M==2) and three rows (N==3). Thus the +** result table has 8 entries. Suppose the result table is stored +** in an array names azResult. Then azResult holds this content: +** +** 
+**        azResult[0] = "Name";
+**        azResult[1] = "Age";
+**        azResult[2] = "Alice";
+**        azResult[3] = "43";
+**        azResult[4] = "Bob";
+**        azResult[5] = "28";
+**        azResult[6] = "Cindy";
+**        azResult[7] = "21";
+**
)^ +** +** ^The sqlite3_get_table() function evaluates one or more +** semicolon-separated SQL statements in the zero-terminated UTF-8 +** string of its 2nd parameter and returns a result table to the +** pointer given in its 3rd parameter. +** +** After the application has finished with the result from sqlite3_get_table(), +** it must pass the result table pointer to sqlite3_free_table() in order to +** release the memory that was malloced. Because of the way the +** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling +** function must not try to call [sqlite3_free()] directly. Only +** [sqlite3_free_table()] is able to release the memory properly and safely. +** +** The sqlite3_get_table() interface is implemented as a wrapper around +** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access +** to any internal data structures of SQLite. It uses only the public +** interface defined here. As a consequence, errors that occur in the +** wrapper layer outside of the internal [sqlite3_exec()] call are not +** reflected in subsequent calls to [sqlite3_errcode()] or +** [sqlite3_errmsg()]. +*/ +SQLITE_API int sqlite3_get_table( + sqlite3 *db, /* An open database */ + const char *zSql, /* SQL to be evaluated */ + char ***pazResult, /* Results of the query */ + int *pnRow, /* Number of result rows written here */ + int *pnColumn, /* Number of result columns written here */ + char **pzErrmsg /* Error msg written here */ +); +SQLITE_API void sqlite3_free_table(char **result); + +/* +** CAPI3REF: Formatted String Printing Functions +** +** These routines are work-alikes of the "printf()" family of functions +** from the standard C library. +** +** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their +** results into memory obtained from [sqlite3_malloc()]. +** The strings returned by these two routines should be +** released by [sqlite3_free()]. ^Both routines return a +** NULL pointer if [sqlite3_malloc()] is unable to allocate enough +** memory to hold the resulting string. +** +** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from +** the standard C library. The result is written into the +** buffer supplied as the second parameter whose size is given by +** the first parameter. Note that the order of the +** first two parameters is reversed from snprintf().)^ This is an +** historical accident that cannot be fixed without breaking +** backwards compatibility. ^(Note also that sqlite3_snprintf() +** returns a pointer to its buffer instead of the number of +** characters actually written into the buffer.)^ We admit that +** the number of characters written would be a more useful return +** value but we cannot change the implementation of sqlite3_snprintf() +** now without breaking compatibility. +** +** ^As long as the buffer size is greater than zero, sqlite3_snprintf() +** guarantees that the buffer is always zero-terminated. ^The first +** parameter "n" is the total size of the buffer, including space for +** the zero terminator. So the longest string that can be completely +** written will be n-1 characters. +** +** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf(). +** +** These routines all implement some additional formatting +** options that are useful for constructing SQL statements. +** All of the usual printf() formatting options apply. In addition, there +** is are "%q", "%Q", and "%z" options. +** +** ^(The %q option works like %s in that it substitutes a nul-terminated +** string from the argument list. But %q also doubles every '\'' character. +** %q is designed for use inside a string literal.)^ By doubling each '\'' +** character it escapes that character and allows it to be inserted into +** the string. +** +** For example, assume the string variable zText contains text as follows: +** +** 
+**  char *zText = "It's a happy day!";
+**
+** +** One can use this text in an SQL statement as follows: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** Because the %q format string is used, the '\'' character in zText +** is escaped and the SQL generated is as follows: +** +** 
+**  INSERT INTO table1 VALUES('It''s a happy day!')
+**
+** +** This is correct. Had we used %s instead of %q, the generated SQL +** would have looked like this: +** +** 
+**  INSERT INTO table1 VALUES('It's a happy day!');
+**
+** +** This second example is an SQL syntax error. As a general rule you should +** always use %q instead of %s when inserting text into a string literal. +** +** ^(The %Q option works like %q except it also adds single quotes around +** the outside of the total string. Additionally, if the parameter in the +** argument list is a NULL pointer, %Q substitutes the text "NULL" (without +** single quotes).)^ So, for example, one could say: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** The code above will render a correct SQL statement in the zSQL +** variable even if the zText variable is a NULL pointer. +** +** ^(The "%z" formatting option works like "%s" but with the +** addition that after the string has been read and copied into +** the result, [sqlite3_free()] is called on the input string.)^ +*/ +SQLITE_API char *sqlite3_mprintf(const char*,...); +SQLITE_API char *sqlite3_vmprintf(const char*, va_list); +SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...); +SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list); + +/* +** CAPI3REF: Memory Allocation Subsystem +** +** The SQLite core uses these three routines for all of its own +** internal memory allocation needs. "Core" in the previous sentence +** does not include operating-system specific VFS implementation. The +** Windows VFS uses native malloc() and free() for some operations. +** +** ^The sqlite3_malloc() routine returns a pointer to a block +** of memory at least N bytes in length, where N is the parameter. +** ^If sqlite3_malloc() is unable to obtain sufficient free +** memory, it returns a NULL pointer. ^If the parameter N to +** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns +** a NULL pointer. +** +** ^Calling sqlite3_free() with a pointer previously returned +** by sqlite3_malloc() or sqlite3_realloc() releases that memory so +** that it might be reused. ^The sqlite3_free() routine is +** a no-op if is called with a NULL pointer. Passing a NULL pointer +** to sqlite3_free() is harmless. After being freed, memory +** should neither be read nor written. Even reading previously freed +** memory might result in a segmentation fault or other severe error. +** Memory corruption, a segmentation fault, or other severe error +** might result if sqlite3_free() is called with a non-NULL pointer that +** was not obtained from sqlite3_malloc() or sqlite3_realloc(). +** +** ^(The sqlite3_realloc() interface attempts to resize a +** prior memory allocation to be at least N bytes, where N is the +** second parameter. The memory allocation to be resized is the first +** parameter.)^ ^ If the first parameter to sqlite3_realloc() +** is a NULL pointer then its behavior is identical to calling +** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). +** ^If the second parameter to sqlite3_realloc() is zero or +** negative then the behavior is exactly the same as calling +** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). +** ^sqlite3_realloc() returns a pointer to a memory allocation +** of at least N bytes in size or NULL if sufficient memory is unavailable. +** ^If M is the size of the prior allocation, then min(N,M) bytes +** of the prior allocation are copied into the beginning of buffer returned +** by sqlite3_realloc() and the prior allocation is freed. +** ^If sqlite3_realloc() returns NULL, then the prior allocation +** is not freed. +** +** ^The memory returned by sqlite3_malloc() and sqlite3_realloc() +** is always aligned to at least an 8 byte boundary, or to a +** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time +** option is used. +** +** In SQLite version 3.5.0 and 3.5.1, it was possible to define +** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in +** implementation of these routines to be omitted. That capability +** is no longer provided. Only built-in memory allocators can be used. +** +** Prior to SQLite version 3.7.10, the Windows OS interface layer called +** the system malloc() and free() directly when converting +** filenames between the UTF-8 encoding used by SQLite +** and whatever filename encoding is used by the particular Windows +** installation. Memory allocation errors were detected, but +** they were reported back as [SQLITE_CANTOPEN] or +** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. +** +** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] +** must be either NULL or else pointers obtained from a prior +** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have +** not yet been released. +** +** The application must not read or write any part of +** a block of memory after it has been released using +** [sqlite3_free()] or [sqlite3_realloc()]. +*/ +SQLITE_API void *sqlite3_malloc(int); +SQLITE_API void *sqlite3_realloc(void*, int); +SQLITE_API void sqlite3_free(void*); + +/* +** CAPI3REF: Memory Allocator Statistics +** +** SQLite provides these two interfaces for reporting on the status +** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] +** routines, which form the built-in memory allocation subsystem. +** +** ^The [sqlite3_memory_used()] routine returns the number of bytes +** of memory currently outstanding (malloced but not freed). +** ^The [sqlite3_memory_highwater()] routine returns the maximum +** value of [sqlite3_memory_used()] since the high-water mark +** was last reset. ^The values returned by [sqlite3_memory_used()] and +** [sqlite3_memory_highwater()] include any overhead +** added by SQLite in its implementation of [sqlite3_malloc()], +** but not overhead added by the any underlying system library +** routines that [sqlite3_malloc()] may call. +** +** ^The memory high-water mark is reset to the current value of +** [sqlite3_memory_used()] if and only if the parameter to +** [sqlite3_memory_highwater()] is true. ^The value returned +** by [sqlite3_memory_highwater(1)] is the high-water mark +** prior to the reset. +*/ +SQLITE_API sqlite3_int64 sqlite3_memory_used(void); +SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag); + +/* +** CAPI3REF: Pseudo-Random Number Generator +** +** SQLite contains a high-quality pseudo-random number generator (PRNG) used to +** select random [ROWID | ROWIDs] when inserting new records into a table that +** already uses the largest possible [ROWID]. The PRNG is also used for +** the build-in random() and randomblob() SQL functions. This interface allows +** applications to access the same PRNG for other purposes. +** +** ^A call to this routine stores N bytes of randomness into buffer P. +** +** ^The first time this routine is invoked (either internally or by +** the application) the PRNG is seeded using randomness obtained +** from the xRandomness method of the default [sqlite3_vfs] object. +** ^On all subsequent invocations, the pseudo-randomness is generated +** internally and without recourse to the [sqlite3_vfs] xRandomness +** method. +*/ +SQLITE_API void sqlite3_randomness(int N, void *P); + +/* +** CAPI3REF: Compile-Time Authorization Callbacks +** +** ^This routine registers an authorizer callback with a particular +** [database connection], supplied in the first argument. +** ^The authorizer callback is invoked as SQL statements are being compiled +** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], +** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various +** points during the compilation process, as logic is being created +** to perform various actions, the authorizer callback is invoked to +** see if those actions are allowed. ^The authorizer callback should +** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the +** specific action but allow the SQL statement to continue to be +** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be +** rejected with an error. ^If the authorizer callback returns +** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] +** then the [sqlite3_prepare_v2()] or equivalent call that triggered +** the authorizer will fail with an error message. +** +** When the callback returns [SQLITE_OK], that means the operation +** requested is ok. ^When the callback returns [SQLITE_DENY], the +** [sqlite3_prepare_v2()] or equivalent call that triggered the +** authorizer will fail with an error message explaining that +** access is denied. +** +** ^The first parameter to the authorizer callback is a copy of the third +** parameter to the sqlite3_set_authorizer() interface. ^The second parameter +** to the callback is an integer [SQLITE_COPY | action code] that specifies +** the particular action to be authorized. ^The third through sixth parameters +** to the callback are zero-terminated strings that contain additional +** details about the action to be authorized. +** +** ^If the action code is [SQLITE_READ] +** and the callback returns [SQLITE_IGNORE] then the +** [prepared statement] statement is constructed to substitute +** a NULL value in place of the table column that would have +** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] +** return can be used to deny an untrusted user access to individual +** columns of a table. +** ^If the action code is [SQLITE_DELETE] and the callback returns +** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the +** [truncate optimization] is disabled and all rows are deleted individually. +** +** An authorizer is used when [sqlite3_prepare | preparing] +** SQL statements from an untrusted source, to ensure that the SQL statements +** do not try to access data they are not allowed to see, or that they do not +** try to execute malicious statements that damage the database. For +** example, an application may allow a user to enter arbitrary +** SQL queries for evaluation by a database. But the application does +** not want the user to be able to make arbitrary changes to the +** database. An authorizer could then be put in place while the +** user-entered SQL is being [sqlite3_prepare | prepared] that +** disallows everything except [SELECT] statements. +** +** Applications that need to process SQL from untrusted sources +** might also consider lowering resource limits using [sqlite3_limit()] +** and limiting database size using the [max_page_count] [PRAGMA] +** in addition to using an authorizer. +** +** ^(Only a single authorizer can be in place on a database connection +** at a time. Each call to sqlite3_set_authorizer overrides the +** previous call.)^ ^Disable the authorizer by installing a NULL callback. +** The authorizer is disabled by default. +** +** The authorizer callback must not do anything that will modify +** the database connection that invoked the authorizer callback. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the +** statement might be re-prepared during [sqlite3_step()] due to a +** schema change. Hence, the application should ensure that the +** correct authorizer callback remains in place during the [sqlite3_step()]. +** +** ^Note that the authorizer callback is invoked only during +** [sqlite3_prepare()] or its variants. Authorization is not +** performed during statement evaluation in [sqlite3_step()], unless +** as stated in the previous paragraph, sqlite3_step() invokes +** sqlite3_prepare_v2() to reprepare a statement after a schema change. +*/ +SQLITE_API int sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); + +/* +** CAPI3REF: Authorizer Return Codes +** +** The [sqlite3_set_authorizer | authorizer callback function] must +** return either [SQLITE_OK] or one of these two constants in order +** to signal SQLite whether or not the action is permitted. See the +** [sqlite3_set_authorizer | authorizer documentation] for additional +** information. +** +** Note that SQLITE_IGNORE is also used as a [SQLITE_ROLLBACK | return code] +** from the [sqlite3_vtab_on_conflict()] interface. +*/ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** CAPI3REF: Authorizer Action Codes +** +** The [sqlite3_set_authorizer()] interface registers a callback function +** that is invoked to authorize certain SQL statement actions. The +** second parameter to the callback is an integer code that specifies +** what action is being authorized. These are the integer action codes that +** the authorizer callback may be passed. +** +** These action code values signify what kind of operation is to be +** authorized. The 3rd and 4th parameters to the authorization +** callback function will be parameters or NULL depending on which of these +** codes is used as the second parameter. ^(The 5th parameter to the +** authorizer callback is the name of the database ("main", "temp", +** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** top-level SQL code. +*/ +/******************************************* 3rd ************ 4th ***********/ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* Operation NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* NULL Function Name */ +#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ +#define SQLITE_COPY 0 /* No longer used */ + +/* +** CAPI3REF: Tracing And Profiling Functions +** +** These routines register callback functions that can be used for +** tracing and profiling the execution of SQL statements. +** +** ^The callback function registered by sqlite3_trace() is invoked at +** various times when an SQL statement is being run by [sqlite3_step()]. +** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the +** SQL statement text as the statement first begins executing. +** ^(Additional sqlite3_trace() callbacks might occur +** as each triggered subprogram is entered. The callbacks for triggers +** contain a UTF-8 SQL comment that identifies the trigger.)^ +** +** ^The callback function registered by sqlite3_profile() is invoked +** as each SQL statement finishes. ^The profile callback contains +** the original statement text and an estimate of wall-clock time +** of how long that statement took to run. ^The profile callback +** time is in units of nanoseconds, however the current implementation +** is only capable of millisecond resolution so the six least significant +** digits in the time are meaningless. Future versions of SQLite +** might provide greater resolution on the profiler callback. The +** sqlite3_profile() function is considered experimental and is +** subject to change in future versions of SQLite. +*/ +SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); +SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite3_uint64), void*); + +/* +** CAPI3REF: Query Progress Callbacks +** +** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback +** function X to be invoked periodically during long running calls to +** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for +** database connection D. An example use for this +** interface is to keep a GUI updated during a large query. +** +** ^The parameter P is passed through as the only parameter to the +** callback function X. ^The parameter N is the number of +** [virtual machine instructions] that are evaluated between successive +** invocations of the callback X. +** +** ^Only a single progress handler may be defined at one time per +** [database connection]; setting a new progress handler cancels the +** old one. ^Setting parameter X to NULL disables the progress handler. +** ^The progress handler is also disabled by setting N to a value less +** than 1. +** +** ^If the progress callback returns non-zero, the operation is +** interrupted. This feature can be used to implement a +** "Cancel" button on a GUI progress dialog box. +** +** The progress handler callback must not do anything that will modify +** the database connection that invoked the progress handler. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +*/ +SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** CAPI3REF: Opening A New Database Connection +** +** ^These routines open an SQLite database file as specified by the +** filename argument. ^The filename argument is interpreted as UTF-8 for +** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte +** order for sqlite3_open16(). ^(A [database connection] handle is usually +** returned in *ppDb, even if an error occurs. The only exception is that +** if SQLite is unable to allocate memory to hold the [sqlite3] object, +** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] +** object.)^ ^(If the database is opened (and/or created) successfully, then +** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The +** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain +** an English language description of the error following a failure of any +** of the sqlite3_open() routines. +** +** ^The default encoding for the database will be UTF-8 if +** sqlite3_open() or sqlite3_open_v2() is called and +** UTF-16 in the native byte order if sqlite3_open16() is used. +** +** Whether or not an error occurs when it is opened, resources +** associated with the [database connection] handle should be released by +** passing it to [sqlite3_close()] when it is no longer required. +** +** The sqlite3_open_v2() interface works like sqlite3_open() +** except that it accepts two additional parameters for additional control +** over the new database connection. ^(The flags parameter to +** sqlite3_open_v2() can take one of +** the following three values, optionally combined with the +** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE], +** [SQLITE_OPEN_PRIVATECACHE], and/or [SQLITE_OPEN_URI] flags:)^ +** +**
+** ^(
[SQLITE_OPEN_READONLY]
+**
The database is opened in read-only mode. If the database does not +** already exist, an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE]
+**
The database is opened for reading and writing if possible, or reading +** only if the file is write protected by the operating system. In either +** case the database must already exist, otherwise an error is returned.
)^ +** +** ^(
[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
+**
The database is opened for reading and writing, and is created if +** it does not already exist. This is the behavior that is always used for +** sqlite3_open() and sqlite3_open16().
)^ +**
+** +** If the 3rd parameter to sqlite3_open_v2() is not one of the +** combinations shown above optionally combined with other +** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] +** then the behavior is undefined. +** +** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection +** opens in the multi-thread [threading mode] as long as the single-thread +** mode has not been set at compile-time or start-time. ^If the +** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens +** in the serialized [threading mode] unless single-thread was +** previously selected at compile-time or start-time. +** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be +** eligible to use [shared cache mode], regardless of whether or not shared +** cache is enabled using [sqlite3_enable_shared_cache()]. ^The +** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not +** participate in [shared cache mode] even if it is enabled. +** +** ^The fourth parameter to sqlite3_open_v2() is the name of the +** [sqlite3_vfs] object that defines the operating system interface that +** the new database connection should use. ^If the fourth parameter is +** a NULL pointer then the default [sqlite3_vfs] object is used. +** +** ^If the filename is ":memory:", then a private, temporary in-memory database +** is created for the connection. ^This in-memory database will vanish when +** the database connection is closed. Future versions of SQLite might +** make use of additional special filenames that begin with the ":" character. +** It is recommended that when a database filename actually does begin with +** a ":" character you should prefix the filename with a pathname such as +** "./" to avoid ambiguity. +** +** ^If the filename is an empty string, then a private, temporary +** on-disk database will be created. ^This private database will be +** automatically deleted as soon as the database connection is closed. +** +** [[URI filenames in sqlite3_open()]]

URI Filenames

+** +** ^If [URI filename] interpretation is enabled, and the filename argument +** begins with "file:", then the filename is interpreted as a URI. ^URI +** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is +** set in the fourth argument to sqlite3_open_v2(), or if it has +** been enabled globally using the [SQLITE_CONFIG_URI] option with the +** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option. +** As of SQLite version 3.7.7, URI filename interpretation is turned off +** by default, but future releases of SQLite might enable URI filename +** interpretation by default. See "[URI filenames]" for additional +** information. +** +** URI filenames are parsed according to RFC 3986. ^If the URI contains an +** authority, then it must be either an empty string or the string +** "localhost". ^If the authority is not an empty string or "localhost", an +** error is returned to the caller. ^The fragment component of a URI, if +** present, is ignored. +** +** ^SQLite uses the path component of the URI as the name of the disk file +** which contains the database. ^If the path begins with a '/' character, +** then it is interpreted as an absolute path. ^If the path does not begin +** with a '/' (meaning that the authority section is omitted from the URI) +** then the path is interpreted as a relative path. +** ^On windows, the first component of an absolute path +** is a drive specification (e.g. "C:"). +** +** [[core URI query parameters]] +** The query component of a URI may contain parameters that are interpreted +** either by SQLite itself, or by a [VFS | custom VFS implementation]. +** SQLite interprets the following three query parameters: +** +**
    +**
  • vfs: ^The "vfs" parameter may be used to specify the name of +** a VFS object that provides the operating system interface that should +** be used to access the database file on disk. ^If this option is set to +** an empty string the default VFS object is used. ^Specifying an unknown +** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is +** present, then the VFS specified by the option takes precedence over +** the value passed as the fourth parameter to sqlite3_open_v2(). +** +**
  • mode: ^(The mode parameter may be set to either "ro", "rw", +** "rwc", or "memory". Attempting to set it to any other value is +** an error)^. +** ^If "ro" is specified, then the database is opened for read-only +** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the +** third argument to sqlite3_open_v2(). ^If the mode option is set to +** "rw", then the database is opened for read-write (but not create) +** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had +** been set. ^Value "rwc" is equivalent to setting both +** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If the mode option is +** set to "memory" then a pure [in-memory database] that never reads +** or writes from disk is used. ^It is an error to specify a value for +** the mode parameter that is less restrictive than that specified by +** the flags passed in the third parameter to sqlite3_open_v2(). +** +**
  • cache: ^The cache parameter may be set to either "shared" or +** "private". ^Setting it to "shared" is equivalent to setting the +** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to +** sqlite3_open_v2(). ^Setting the cache parameter to "private" is +** equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit. +** ^If sqlite3_open_v2() is used and the "cache" parameter is present in +** a URI filename, its value overrides any behavior requested by setting +** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag. +**
+** +** ^Specifying an unknown parameter in the query component of a URI is not an +** error. Future versions of SQLite might understand additional query +** parameters. See "[query parameters with special meaning to SQLite]" for +** additional information. +** +** [[URI filename examples]]

URI filename examples

+** +** +**
URI filenames Results +**
file:data.db +** Open the file "data.db" in the current directory. +**
file:/home/fred/data.db
+** file:///home/fred/data.db
+** file://localhost/home/fred/data.db
+** Open the database file "/home/fred/data.db". +**
file://darkstar/home/fred/data.db +** An error. "darkstar" is not a recognized authority. +**
+** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db +** Windows only: Open the file "data.db" on fred's desktop on drive +** C:. Note that the %20 escaping in this example is not strictly +** necessary - space characters can be used literally +** in URI filenames. +**
file:data.db?mode=ro&cache=private +** Open file "data.db" in the current directory for read-only access. +** Regardless of whether or not shared-cache mode is enabled by +** default, use a private cache. +**
file:/home/fred/data.db?vfs=unix-nolock +** Open file "/home/fred/data.db". Use the special VFS "unix-nolock". +**
file:data.db?mode=readonly +** An error. "readonly" is not a valid option for the "mode" parameter. +**
+** +** ^URI hexadecimal escape sequences (%HH) are supported within the path and +** query components of a URI. A hexadecimal escape sequence consists of a +** percent sign - "%" - followed by exactly two hexadecimal digits +** specifying an octet value. ^Before the path or query components of a +** URI filename are interpreted, they are encoded using UTF-8 and all +** hexadecimal escape sequences replaced by a single byte containing the +** corresponding octet. If this process generates an invalid UTF-8 encoding, +** the results are undefined. +** +** Note to Windows users: The encoding used for the filename argument +** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever +** codepage is currently defined. Filenames containing international +** characters must be converted to UTF-8 prior to passing them into +** sqlite3_open() or sqlite3_open_v2(). +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling sqlite3_open() or sqlite3_open_v2(). Otherwise, various +** features that require the use of temporary files may fail. +** +** See also: [sqlite3_temp_directory] +*/ +SQLITE_API int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +SQLITE_API int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +); + +/* +** CAPI3REF: Obtain Values For URI Parameters +** +** These are utility routines, useful to VFS implementations, that check +** to see if a database file was a URI that contained a specific query +** parameter, and if so obtains the value of that query parameter. +** +** If F is the database filename pointer passed into the xOpen() method of +** a VFS implementation when the flags parameter to xOpen() has one or +** more of the [SQLITE_OPEN_URI] or [SQLITE_OPEN_MAIN_DB] bits set and +** P is the name of the query parameter, then +** sqlite3_uri_parameter(F,P) returns the value of the P +** parameter if it exists or a NULL pointer if P does not appear as a +** query parameter on F. If P is a query parameter of F +** has no explicit value, then sqlite3_uri_parameter(F,P) returns +** a pointer to an empty string. +** +** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean +** parameter and returns true (1) or false (0) according to the value +** of P. The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the +** value of query parameter P is one of "yes", "true", or "on" in any +** case or if the value begins with a non-zero number. The +** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of +** query parameter P is one of "no", "false", or "off" in any case or +** if the value begins with a numeric zero. If P is not a query +** parameter on F or if the value of P is does not match any of the +** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0). +** +** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a +** 64-bit signed integer and returns that integer, or D if P does not +** exist. If the value of P is something other than an integer, then +** zero is returned. +** +** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and +** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and +** is not a database file pathname pointer that SQLite passed into the xOpen +** VFS method, then the behavior of this routine is undefined and probably +** undesirable. +*/ +SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam); +SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault); +SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64); + + +/* +** CAPI3REF: Error Codes And Messages +** +** ^The sqlite3_errcode() interface returns the numeric [result code] or +** [extended result code] for the most recent failed sqlite3_* API call +** associated with a [database connection]. If a prior API call failed +** but the most recent API call succeeded, the return value from +** sqlite3_errcode() is undefined. ^The sqlite3_extended_errcode() +** interface is the same except that it always returns the +** [extended result code] even when extended result codes are +** disabled. +** +** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF-8 or UTF-16 respectively. +** ^(Memory to hold the error message string is managed internally. +** The application does not need to worry about freeing the result. +** However, the error string might be overwritten or deallocated by +** subsequent calls to other SQLite interface functions.)^ +** +** ^The sqlite3_errstr() interface returns the English-language text +** that describes the [result code], as UTF-8. +** ^(Memory to hold the error message string is managed internally +** and must not be freed by the application)^. +** +** When the serialized [threading mode] is in use, it might be the +** case that a second error occurs on a separate thread in between +** the time of the first error and the call to these interfaces. +** When that happens, the second error will be reported since these +** interfaces always report the most recent result. To avoid +** this, each thread can obtain exclusive use of the [database connection] D +** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning +** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after +** all calls to the interfaces listed here are completed. +** +** If an interface fails with SQLITE_MISUSE, that means the interface +** was invoked incorrectly by the application. In that case, the +** error code and message may or may not be set. +*/ +SQLITE_API int sqlite3_errcode(sqlite3 *db); +SQLITE_API int sqlite3_extended_errcode(sqlite3 *db); +SQLITE_API const char *sqlite3_errmsg(sqlite3*); +SQLITE_API const void *sqlite3_errmsg16(sqlite3*); +SQLITE_API const char *sqlite3_errstr(int); + +/* +** CAPI3REF: SQL Statement Object +** KEYWORDS: {prepared statement} {prepared statements} +** +** An instance of this object represents a single SQL statement. +** This object is variously known as a "prepared statement" or a +** "compiled SQL statement" or simply as a "statement". +** +** The life of a statement object goes something like this: +** +**
    +**
  1. Create the object using [sqlite3_prepare_v2()] or a related +** function. +**
  2. Bind values to [host parameters] using the sqlite3_bind_*() +** interfaces. +**
  3. Run the SQL by calling [sqlite3_step()] one or more times. +**
  4. Reset the statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
  5. Destroy the object using [sqlite3_finalize()]. +**
+** +** Refer to documentation on individual methods above for additional +** information. +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Run-time Limits +** +** ^(This interface allows the size of various constructs to be limited +** on a connection by connection basis. The first parameter is the +** [database connection] whose limit is to be set or queried. The +** second parameter is one of the [limit categories] that define a +** class of constructs to be size limited. The third parameter is the +** new limit for that construct.)^ +** +** ^If the new limit is a negative number, the limit is unchanged. +** ^(For each limit category SQLITE_LIMIT_NAME there is a +** [limits | hard upper bound] +** set at compile-time by a C preprocessor macro called +** [limits | SQLITE_MAX_NAME]. +** (The "_LIMIT_" in the name is changed to "_MAX_".))^ +** ^Attempts to increase a limit above its hard upper bound are +** silently truncated to the hard upper bound. +** +** ^Regardless of whether or not the limit was changed, the +** [sqlite3_limit()] interface returns the prior value of the limit. +** ^Hence, to find the current value of a limit without changing it, +** simply invoke this interface with the third parameter set to -1. +** +** Run-time limits are intended for use in applications that manage +** both their own internal database and also databases that are controlled +** by untrusted external sources. An example application might be a +** web browser that has its own databases for storing history and +** separate databases controlled by JavaScript applications downloaded +** off the Internet. The internal databases can be given the +** large, default limits. Databases managed by external sources can +** be given much smaller limits designed to prevent a denial of service +** attack. Developers might also want to use the [sqlite3_set_authorizer()] +** interface to further control untrusted SQL. The size of the database +** created by an untrusted script can be contained using the +** [max_page_count] [PRAGMA]. +** +** New run-time limit categories may be added in future releases. +*/ +SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal); + +/* +** CAPI3REF: Run-Time Limit Categories +** KEYWORDS: {limit category} {*limit categories} +** +** These constants define various performance limits +** that can be lowered at run-time using [sqlite3_limit()]. +** The synopsis of the meanings of the various limits is shown below. +** Additional information is available at [limits | Limits in SQLite]. +** +**
+** [[SQLITE_LIMIT_LENGTH]] ^(
SQLITE_LIMIT_LENGTH
+**
The maximum size of any string or BLOB or table row, in bytes.
)^ +** +** [[SQLITE_LIMIT_SQL_LENGTH]] ^(
SQLITE_LIMIT_SQL_LENGTH
+**
The maximum length of an SQL statement, in bytes.
)^ +** +** [[SQLITE_LIMIT_COLUMN]] ^(
SQLITE_LIMIT_COLUMN
+**
The maximum number of columns in a table definition or in the +** result set of a [SELECT] or the maximum number of columns in an index +** or in an ORDER BY or GROUP BY clause.
)^ +** +** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(
SQLITE_LIMIT_EXPR_DEPTH
+**
The maximum depth of the parse tree on any expression.
)^ +** +** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(
SQLITE_LIMIT_COMPOUND_SELECT
+**
The maximum number of terms in a compound SELECT statement.
)^ +** +** [[SQLITE_LIMIT_VDBE_OP]] ^(
SQLITE_LIMIT_VDBE_OP
+**
The maximum number of instructions in a virtual machine program +** used to implement an SQL statement. This limit is not currently +** enforced, though that might be added in some future release of +** SQLite.
)^ +** +** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(
SQLITE_LIMIT_FUNCTION_ARG
+**
The maximum number of arguments on a function.
)^ +** +** [[SQLITE_LIMIT_ATTACHED]] ^(
SQLITE_LIMIT_ATTACHED
+**
The maximum number of [ATTACH | attached databases].)^
+** +** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]] +** ^(
SQLITE_LIMIT_LIKE_PATTERN_LENGTH
+**
The maximum length of the pattern argument to the [LIKE] or +** [GLOB] operators.
)^ +** +** [[SQLITE_LIMIT_VARIABLE_NUMBER]] +** ^(
SQLITE_LIMIT_VARIABLE_NUMBER
+**
The maximum index number of any [parameter] in an SQL statement.)^ +** +** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(
SQLITE_LIMIT_TRIGGER_DEPTH
+**
The maximum depth of recursion for triggers.
)^ +**
+*/ +#define SQLITE_LIMIT_LENGTH 0 +#define SQLITE_LIMIT_SQL_LENGTH 1 +#define SQLITE_LIMIT_COLUMN 2 +#define SQLITE_LIMIT_EXPR_DEPTH 3 +#define SQLITE_LIMIT_COMPOUND_SELECT 4 +#define SQLITE_LIMIT_VDBE_OP 5 +#define SQLITE_LIMIT_FUNCTION_ARG 6 +#define SQLITE_LIMIT_ATTACHED 7 +#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 +#define SQLITE_LIMIT_VARIABLE_NUMBER 9 +#define SQLITE_LIMIT_TRIGGER_DEPTH 10 + +/* +** CAPI3REF: Compiling An SQL Statement +** KEYWORDS: {SQL statement compiler} +** +** To execute an SQL query, it must first be compiled into a byte-code +** program using one of these routines. +** +** The first argument, "db", is a [database connection] obtained from a +** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or +** [sqlite3_open16()]. The database connection must not have been closed. +** +** The second argument, "zSql", is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() +** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2() +** use UTF-16. +** +** ^If the nByte argument is less than zero, then zSql is read up to the +** first zero terminator. ^If nByte is non-negative, then it is the maximum +** number of bytes read from zSql. ^When nByte is non-negative, the +** zSql string ends at either the first '\000' or '\u0000' character or +** the nByte-th byte, whichever comes first. If the caller knows +** that the supplied string is nul-terminated, then there is a small +** performance advantage to be gained by passing an nByte parameter that +** is equal to the number of bytes in the input string including +** the nul-terminator bytes as this saves SQLite from having to +** make a copy of the input string. +** +** ^If pzTail is not NULL then *pzTail is made to point to the first byte +** past the end of the first SQL statement in zSql. These routines only +** compile the first statement in zSql, so *pzTail is left pointing to +** what remains uncompiled. +** +** ^*ppStmt is left pointing to a compiled [prepared statement] that can be +** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set +** to NULL. ^If the input text contains no SQL (if the input is an empty +** string or a comment) then *ppStmt is set to NULL. +** The calling procedure is responsible for deleting the compiled +** SQL statement using [sqlite3_finalize()] after it has finished with it. +** ppStmt may not be NULL. +** +** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK]; +** otherwise an [error code] is returned. +** +** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are +** recommended for all new programs. The two older interfaces are retained +** for backwards compatibility, but their use is discouraged. +** ^In the "v2" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. This causes the [sqlite3_step()] interface to +** behave differently in three ways: +** +**
    +**
  1. +** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. +**
    2. +** +**
  2. +** ^When an error occurs, [sqlite3_step()] will return one of the detailed +** [error codes] or [extended error codes]. ^The legacy behavior was that +** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code +** and the application would have to make a second call to [sqlite3_reset()] +** in order to find the underlying cause of the problem. With the "v2" prepare +** interfaces, the underlying reason for the error is returned immediately. +**
    3. +** +**
  3. +** ^If the specific value bound to [parameter | host parameter] in the +** WHERE clause might influence the choice of query plan for a statement, +** then the statement will be automatically recompiled, as if there had been +** a schema change, on the first [sqlite3_step()] call following any change +** to the [sqlite3_bind_text | bindings] of that [parameter]. +** ^The specific value of WHERE-clause [parameter] might influence the +** choice of query plan if the parameter is the left-hand side of a [LIKE] +** or [GLOB] operator or if the parameter is compared to an indexed column +** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled. +** the +**
    4. +**
+*/ +SQLITE_API int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +SQLITE_API int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPI3REF: Retrieving Statement SQL +** +** ^This interface can be used to retrieve a saved copy of the original +** SQL text used to create a [prepared statement] if that statement was +** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()]. +*/ +SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If An SQL Statement Writes The Database +** +** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if +** and only if the [prepared statement] X makes no direct changes to +** the content of the database file. +** +** Note that [application-defined SQL functions] or +** [virtual tables] might change the database indirectly as a side effect. +** ^(For example, if an application defines a function "eval()" that +** calls [sqlite3_exec()], then the following SQL statement would +** change the database file through side-effects: +** +** 
+**    SELECT eval('DELETE FROM t1') FROM t2;
+**
+** +** But because the [SELECT] statement does not change the database file +** directly, sqlite3_stmt_readonly() would still return true.)^ +** +** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK], +** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true, +** since the statements themselves do not actually modify the database but +** rather they control the timing of when other statements modify the +** database. ^The [ATTACH] and [DETACH] statements also cause +** sqlite3_stmt_readonly() to return true since, while those statements +** change the configuration of a database connection, they do not make +** changes to the content of the database files on disk. +*/ +SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Determine If A Prepared Statement Has Been Reset +** +** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the +** [prepared statement] S has been stepped at least once using +** [sqlite3_step(S)] but has not run to completion and/or has not +** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S) +** interface returns false if S is a NULL pointer. If S is not a +** NULL pointer and is not a pointer to a valid [prepared statement] +** object, then the behavior is undefined and probably undesirable. +** +** This interface can be used in combination [sqlite3_next_stmt()] +** to locate all prepared statements associated with a database +** connection that are in need of being reset. This can be used, +** for example, in diagnostic routines to search for prepared +** statements that are holding a transaction open. +*/ +SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*); + +/* +** CAPI3REF: Dynamically Typed Value Object +** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value} +** +** SQLite uses the sqlite3_value object to represent all values +** that can be stored in a database table. SQLite uses dynamic typing +** for the values it stores. ^Values stored in sqlite3_value objects +** can be integers, floating point values, strings, BLOBs, or NULL. +** +** An sqlite3_value object may be either "protected" or "unprotected". +** Some interfaces require a protected sqlite3_value. Other interfaces +** will accept either a protected or an unprotected sqlite3_value. +** Every interface that accepts sqlite3_value arguments specifies +** whether or not it requires a protected sqlite3_value. +** +** The terms "protected" and "unprotected" refer to whether or not +** a mutex is held. An internal mutex is held for a protected +** sqlite3_value object but no mutex is held for an unprotected +** sqlite3_value object. If SQLite is compiled to be single-threaded +** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0) +** or if SQLite is run in one of reduced mutex modes +** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD] +** then there is no distinction between protected and unprotected +** sqlite3_value objects and they can be used interchangeably. However, +** for maximum code portability it is recommended that applications +** still make the distinction between protected and unprotected +** sqlite3_value objects even when not strictly required. +** +** ^The sqlite3_value objects that are passed as parameters into the +** implementation of [application-defined SQL functions] are protected. +** ^The sqlite3_value object returned by +** [sqlite3_column_value()] is unprotected. +** Unprotected sqlite3_value objects may only be used with +** [sqlite3_result_value()] and [sqlite3_bind_value()]. +** The [sqlite3_value_blob | sqlite3_value_type()] family of +** interfaces require protected sqlite3_value objects. +*/ +typedef struct Mem sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. ^A pointer to an sqlite3_context object +** is always first parameter to [application-defined SQL functions]. +** The application-defined SQL function implementation will pass this +** pointer through into calls to [sqlite3_result_int | sqlite3_result()], +** [sqlite3_aggregate_context()], [sqlite3_user_data()], +** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()], +** and/or [sqlite3_set_auxdata()]. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements +** KEYWORDS: {host parameter} {host parameters} {host parameter name} +** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding} +** +** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants, +** literals may be replaced by a [parameter] that matches one of following +** templates: +** +**
    +**
  • ? +**
  • ?NNN +**
  • :VVV +**
  • @VVV +**
  • $VVV +**
+** +** In the templates above, NNN represents an integer literal, +** and VVV represents an alphanumeric identifier.)^ ^The values of these +** parameters (also called "host parameter names" or "SQL parameters") +** can be set using the sqlite3_bind_*() routines defined here. +** +** ^The first argument to the sqlite3_bind_*() routines is always +** a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. +** +** ^The second argument is the index of the SQL parameter to be set. +** ^The leftmost SQL parameter has an index of 1. ^When the same named +** SQL parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** ^The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_index()] API if desired. ^The index +** for "?NNN" parameters is the value of NNN. +** ^The NNN value must be between 1 and the [sqlite3_limit()] +** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999). +** +** ^The third argument is the value to bind to the parameter. +** +** ^(In those routines that have a fourth argument, its value is the +** number of bytes in the parameter. To be clear: the value is the +** number of bytes in the value, not the number of characters.)^ +** ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16() +** is negative, then the length of the string is +** the number of bytes up to the first zero terminator. +** If the fourth parameter to sqlite3_bind_blob() is negative, then +** the behavior is undefined. +** If a non-negative fourth parameter is provided to sqlite3_bind_text() +** or sqlite3_bind_text16() then that parameter must be the byte offset +** where the NUL terminator would occur assuming the string were NUL +** terminated. If any NUL characters occur at byte offsets less than +** the value of the fourth parameter then the resulting string value will +** contain embedded NULs. The result of expressions involving strings +** with embedded NULs is undefined. +** +** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and +** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or +** string after SQLite has finished with it. ^The destructor is called +** to dispose of the BLOB or string even if the call to sqlite3_bind_blob(), +** sqlite3_bind_text(), or sqlite3_bind_text16() fails. +** ^If the fifth argument is +** the special value [SQLITE_STATIC], then SQLite assumes that the +** information is in static, unmanaged space and does not need to be freed. +** ^If the fifth argument has the value [SQLITE_TRANSIENT], then +** SQLite makes its own private copy of the data immediately, before +** the sqlite3_bind_*() routine returns. +** +** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeroes. ^A zeroblob uses a fixed amount of memory +** (just an integer to hold its size) while it is being processed. +** Zeroblobs are intended to serve as placeholders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | incremental BLOB I/O] routines. +** ^A negative value for the zeroblob results in a zero-length BLOB. +** +** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer +** for the [prepared statement] or with a prepared statement for which +** [sqlite3_step()] has been called more recently than [sqlite3_reset()], +** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_() +** routine is passed a [prepared statement] that has been finalized, the +** result is undefined and probably harmful. +** +** ^Bindings are not cleared by the [sqlite3_reset()] routine. +** ^Unbound parameters are interpreted as NULL. +** +** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an +** [error code] if anything goes wrong. +** ^[SQLITE_RANGE] is returned if the parameter +** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails. +** +** See also: [sqlite3_bind_parameter_count()], +** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double); +SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int); +SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int); +SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); +SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); + +/* +** CAPI3REF: Number Of SQL Parameters +** +** ^This routine can be used to find the number of [SQL parameters] +** in a [prepared statement]. SQL parameters are tokens of the +** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as +** placeholders for values that are [sqlite3_bind_blob | bound] +** to the parameters at a later time. +** +** ^(This routine actually returns the index of the largest (rightmost) +** parameter. For all forms except ?NNN, this will correspond to the +** number of unique parameters. If parameters of the ?NNN form are used, +** there may be gaps in the list.)^ +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_name()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter +** +** ^The sqlite3_bind_parameter_name(P,N) interface returns +** the name of the N-th [SQL parameter] in the [prepared statement] P. +** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA" +** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA" +** respectively. +** In other words, the initial ":" or "$" or "@" or "?" +** is included as part of the name.)^ +** ^Parameters of the form "?" without a following integer have no name +** and are referred to as "nameless" or "anonymous parameters". +** +** ^The first host parameter has an index of 1, not 0. +** +** ^If the value N is out of range or if the N-th parameter is +** nameless, then NULL is returned. ^The returned string is +** always in UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()] or +** [sqlite3_prepare16_v2()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name +** +** ^Return the index of an SQL parameter given its name. ^The +** index value returned is suitable for use as the second +** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero +** is returned if no matching parameter is found. ^The parameter +** name must be given in UTF-8 even if the original statement +** was prepared from UTF-16 text using [sqlite3_prepare16_v2()]. +** +** See also: [sqlite3_bind_blob|sqlite3_bind()], +** [sqlite3_bind_parameter_count()], and +** [sqlite3_bind_parameter_index()]. +*/ +SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement +** +** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset +** the [sqlite3_bind_blob | bindings] on a [prepared statement]. +** ^Use this routine to reset all host parameters to NULL. +*/ +SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set +** +** ^Return the number of columns in the result set returned by the +** [prepared statement]. ^This routine returns 0 if pStmt is an SQL +** statement that does not return data (for example an [UPDATE]). +** +** See also: [sqlite3_data_count()] +*/ +SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set +** +** ^These routines return the name assigned to a particular column +** in the result set of a [SELECT] statement. ^The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF-8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF-16 string. ^The first parameter is the [prepared statement] +** that implements the [SELECT] statement. ^The second parameter is the +** column number. ^The leftmost column is number 0. +** +** ^The returned string pointer is valid until either the [prepared statement] +** is destroyed by [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the next call to +** sqlite3_column_name() or sqlite3_column_name16() on the same column. +** +** ^If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +** +** ^The name of a result column is the value of the "AS" clause for +** that column, if there is an AS clause. If there is no AS clause +** then the name of the column is unspecified and may change from +** one release of SQLite to the next. +*/ +SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N); +SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result +** +** ^These routines provide a means to determine the database, table, and +** table column that is the origin of a particular result column in +** [SELECT] statement. +** ^The name of the database or table or column can be returned as +** either a UTF-8 or UTF-16 string. ^The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. +** ^The returned string is valid until the [prepared statement] is destroyed +** using [sqlite3_finalize()] or until the statement is automatically +** reprepared by the first call to [sqlite3_step()] for a particular run +** or until the same information is requested +** again in a different encoding. +** +** ^The names returned are the original un-aliased names of the +** database, table, and column. +** +** ^The first argument to these interfaces is a [prepared statement]. +** ^These functions return information about the Nth result column returned by +** the statement, where N is the second function argument. +** ^The left-most column is column 0 for these routines. +** +** ^If the Nth column returned by the statement is an expression or +** subquery and is not a column value, then all of these functions return +** NULL. ^These routine might also return NULL if a memory allocation error +** occurs. ^Otherwise, they return the name of the attached database, table, +** or column that query result column was extracted from. +** +** ^As with all other SQLite APIs, those whose names end with "16" return +** UTF-16 encoded strings and the other functions return UTF-8. +** +** ^These APIs are only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol. +** +** If two or more threads call one or more of these routines against the same +** prepared statement and column at the same time then the results are +** undefined. +** +** If two or more threads call one or more +** [sqlite3_column_database_name | column metadata interfaces] +** for the same [prepared statement] and result column +** at the same time then the results are undefined. +*/ +SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result +** +** ^(The first parameter is a [prepared statement]. +** If this statement is a [SELECT] statement and the Nth column of the +** returned result set of that [SELECT] is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned.)^ ^If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** ^The returned string is always UTF-8 encoded. +** +** ^(For example, given the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** and the following statement to be compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** this routine would return the string "VARIANT" for the second result +** column (i==1), and a NULL pointer for the first result column (i==0).)^ +** +** ^SQLite uses dynamic run-time typing. ^So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. ^Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int); +SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement +** +** After a [prepared statement] has been prepared using either +** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function +** must be called one or more times to evaluate the statement. +** +** The details of the behavior of the sqlite3_step() interface depend +** on whether the statement was prepared using the newer "v2" interface +** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy +** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "v2" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** ^In the legacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** ^With the "v2" interface, any of the other [result codes] or +** [extended result codes] might be returned as well. +** +** ^[SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. ^If the statement is a [COMMIT] +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a [COMMIT] and occurs within an +** explicit transaction then you should rollback the transaction before +** continuing. +** +** ^[SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** ^If the SQL statement being executed returns any data, then [SQLITE_ROW] +** is returned each time a new row of data is ready for processing by the +** caller. The values may be accessed using the [column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** ^[SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** ^With the legacy interface, a more specific error code (for example, +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [prepared statement]. ^In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** For all versions of SQLite up to and including 3.6.23.1, a call to +** [sqlite3_reset()] was required after sqlite3_step() returned anything +** other than [SQLITE_ROW] before any subsequent invocation of +** sqlite3_step(). Failure to reset the prepared statement using +** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from +** sqlite3_step(). But after version 3.6.23.1, sqlite3_step() began +** calling [sqlite3_reset()] automatically in this circumstance rather +** than returning [SQLITE_MISUSE]. This is not considered a compatibility +** break because any application that ever receives an SQLITE_MISUSE error +** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option +** can be used to restore the legacy behavior. +** +** Goofy Interface Alert: In the legacy interface, the sqlite3_step() +** API always returns a generic error code, [SQLITE_ERROR], following any +** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call +** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the +** specific [error codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces, +** then the more specific [error codes] are returned directly +** by sqlite3_step(). The use of the "v2" interface is recommended. +*/ +SQLITE_API int sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set +** +** ^The sqlite3_data_count(P) interface returns the number of columns in the +** current row of the result set of [prepared statement] P. +** ^If prepared statement P does not have results ready to return +** (via calls to the [sqlite3_column_int | sqlite3_column_*()] of +** interfaces) then sqlite3_data_count(P) returns 0. +** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer. +** ^The sqlite3_data_count(P) routine returns 0 if the previous call to +** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P) +** will return non-zero if previous call to [sqlite3_step](P) returned +** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum] +** where it always returns zero since each step of that multi-step +** pragma returns 0 columns of data. +** +** See also: [sqlite3_column_count()] +*/ +SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes +** KEYWORDS: SQLITE_TEXT +** +** ^(Every value in SQLite has one of five fundamental datatypes: +** +**
    +**
  • 64-bit signed integer +**
  • 64-bit IEEE floating point number +**
  • string +**
  • BLOB +**
  • NULL +**
)^ +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Result Values From A Query +** KEYWORDS: {column access functions} +** +** These routines form the "result set" interface. +** +** ^These routines return information about a single column of the current +** result row of a query. ^In every case the first argument is a pointer +** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*] +** that was returned from [sqlite3_prepare_v2()] or one of its variants) +** and the second argument is the index of the column for which information +** should be returned. ^The leftmost column of the result set has the index 0. +** ^The number of columns in the result can be determined using +** [sqlite3_column_count()]. +** +** If the SQL statement does not currently point to a valid row, or if the +** column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** ^The sqlite3_column_type() routine returns the +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. ^The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value +** returned by sqlite3_column_type() is only meaningful if no type +** conversions have occurred as described below. After a type conversion, +** the value returned by sqlite3_column_type() is undefined. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes() returns zero. +** +** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16() +** routine returns the number of bytes in that BLOB or string. +** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts +** the string to UTF-16 and then returns the number of bytes. +** ^If the result is a numeric value then sqlite3_column_bytes16() uses +** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns +** the number of bytes in that string. +** ^If the result is NULL, then sqlite3_column_bytes16() returns zero. +** +** ^The values returned by [sqlite3_column_bytes()] and +** [sqlite3_column_bytes16()] do not include the zero terminators at the end +** of the string. ^For clarity: the values returned by +** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of +** bytes in the string, not the number of characters. +** +** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even empty strings, are always zero-terminated. ^The return +** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer. +** +** ^The object returned by [sqlite3_column_value()] is an +** [unprotected sqlite3_value] object. An unprotected sqlite3_value object +** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()]. +** If the [unprotected sqlite3_value] object returned by +** [sqlite3_column_value()] is used in any other way, including calls +** to routines like [sqlite3_value_int()], [sqlite3_value_text()], +** or [sqlite3_value_bytes()], then the behavior is undefined. +** +** These routines attempt to convert the value where appropriate. ^For +** example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to perform the +** conversion automatically. ^(The following table details the conversions +** that are applied: +** +**
+** +**
Internal
Type 		Requested
Type 		Conversion +** +**
NULL INTEGER Result is 0 +**
NULL FLOAT Result is 0.0 +**
NULL TEXT Result is NULL pointer +**
NULL BLOB Result is NULL pointer +**
INTEGER FLOAT Convert from integer to float +**
INTEGER TEXT ASCII rendering of the integer +**
INTEGER BLOB Same as INTEGER->TEXT +**
FLOAT INTEGER Convert from float to integer +**
FLOAT TEXT ASCII rendering of the float +**
FLOAT BLOB Same as FLOAT->TEXT +**
TEXT INTEGER Use atoi() +**
TEXT FLOAT Use atof() +**
TEXT BLOB No change +**
BLOB INTEGER Convert to TEXT then use atoi() +**
BLOB FLOAT Convert to TEXT then use atof() +**
BLOB TEXT Add a zero terminator if needed +**
+**
)^ +** +** The table above makes reference to standard C library functions atoi() +** and atof(). SQLite does not really use these functions. It has its +** own equivalent internal routines. The atoi() and atof() names are +** used in the table for brevity and because they are familiar to most +** C programmers. +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +**
    +**
  • The initial content is a BLOB and sqlite3_column_text() or +** sqlite3_column_text16() is called. A zero-terminator might +** need to be added to the string.
    • +**
  • The initial content is UTF-8 text and sqlite3_column_bytes16() or +** sqlite3_column_text16() is called. The content must be converted +** to UTF-16.
    • +**
  • The initial content is UTF-16 text and sqlite3_column_bytes() or +** sqlite3_column_text() is called. The content must be converted +** to UTF-8.
    • +**
+** +** ^Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer references will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometimes they +** are not possible and in those cases prior pointers are invalidated. +** +** The safest and easiest to remember policy is to invoke these routines +** in one of the following ways: +** +**
    +**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • +**
+** +** In other words, you should call sqlite3_column_text(), +** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result +** into the desired format, then invoke sqlite3_column_bytes() or +** sqlite3_column_bytes16() to find the size of the result. Do not mix calls +** to sqlite3_column_text() or sqlite3_column_blob() with calls to +** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16() +** with calls to sqlite3_column_bytes(). +** +** ^The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. ^The memory space used to hold strings +** and BLOBs is freed automatically. Do not pass the pointers returned +** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** ^(If a memory allocation error occurs during the evaluation of any +** of these routines, a default value is returned. The default value +** is either the integer 0, the floating point number 0.0, or a NULL +** pointer. Subsequent calls to [sqlite3_errcode()] will return +** [SQLITE_NOMEM].)^ +*/ +SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol); +SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object +** +** ^The sqlite3_finalize() function is called to delete a [prepared statement]. +** ^If the most recent evaluation of the statement encountered no errors +** or if the statement is never been evaluated, then sqlite3_finalize() returns +** SQLITE_OK. ^If the most recent evaluation of statement S failed, then +** sqlite3_finalize(S) returns the appropriate [error code] or +** [extended error code]. +** +** ^The sqlite3_finalize(S) routine can be called at any point during +** the life cycle of [prepared statement] S: +** before statement S is ever evaluated, after +** one or more calls to [sqlite3_reset()], or after any call +** to [sqlite3_step()] regardless of whether or not the statement has +** completed execution. +** +** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op. +** +** The application must finalize every [prepared statement] in order to avoid +** resource leaks. It is a grievous error for the application to try to use +** a prepared statement after it has been finalized. Any use of a prepared +** statement after it has been finalized can result in undefined and +** undesirable behavior such as segfaults and heap corruption. +*/ +SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object +** +** The sqlite3_reset() function is called to reset a [prepared statement] +** object back to its initial state, ready to be re-executed. +** ^Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +** +** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S +** back to the beginning of its program. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE], +** or if [sqlite3_step(S)] has never before been called on S, +** then [sqlite3_reset(S)] returns [SQLITE_OK]. +** +** ^If the most recent call to [sqlite3_step(S)] for the +** [prepared statement] S indicated an error, then +** [sqlite3_reset(S)] returns an appropriate [error code]. +** +** ^The [sqlite3_reset(S)] interface does not change the values +** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S. +*/ +SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions +** KEYWORDS: {function creation routines} +** KEYWORDS: {application-defined SQL function} +** KEYWORDS: {application-defined SQL functions} +** +** ^These functions (collectively known as "function creation routines") +** are used to add SQL functions or aggregates or to redefine the behavior +** of existing SQL functions or aggregates. The only differences between +** these routines are the text encoding expected for +** the second parameter (the name of the function being created) +** and the presence or absence of a destructor callback for +** the application data pointer. +** +** ^The first parameter is the [database connection] to which the SQL +** function is to be added. ^If an application uses more than one database +** connection then application-defined SQL functions must be added +** to each database connection separately. +** +** ^The second parameter is the name of the SQL function to be created or +** redefined. ^The length of the name is limited to 255 bytes in a UTF-8 +** representation, exclusive of the zero-terminator. ^Note that the name +** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes. +** ^Any attempt to create a function with a longer name +** will result in [SQLITE_MISUSE] being returned. +** +** ^The third parameter (nArg) +** is the number of arguments that the SQL function or +** aggregate takes. ^If this parameter is -1, then the SQL function or +** aggregate may take any number of arguments between 0 and the limit +** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third +** parameter is less than -1 or greater than 127 then the behavior is +** undefined. +** +** ^The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. Every SQL function implementation must be able to work +** with UTF-8, UTF-16le, or UTF-16be. But some implementations may be +** more efficient with one encoding than another. ^An application may +** invoke sqlite3_create_function() or sqlite3_create_function16() multiple +** times with the same function but with different values of eTextRep. +** ^When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** If there is only a single implementation which does not care what text +** encoding is used, then the fourth argument should be [SQLITE_ANY]. +** +** ^(The fifth parameter is an arbitrary pointer. The implementation of the +** function can gain access to this pointer using [sqlite3_user_data()].)^ +** +** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL function or +** aggregate. ^A scalar SQL function requires an implementation of the xFunc +** callback only; NULL pointers must be passed as the xStep and xFinal +** parameters. ^An aggregate SQL function requires an implementation of xStep +** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing +** SQL function or aggregate, pass NULL pointers for all three function +** callbacks. +** +** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL, +** then it is destructor for the application data pointer. +** The destructor is invoked when the function is deleted, either by being +** overloaded or when the database connection closes.)^ +** ^The destructor is also invoked if the call to +** sqlite3_create_function_v2() fails. +** ^When the destructor callback of the tenth parameter is invoked, it +** is passed a single argument which is a copy of the application data +** pointer which was the fifth parameter to sqlite3_create_function_v2(). +** +** ^It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing preferred text encodings. ^SQLite will use +** the implementation that most closely matches the way in which the +** SQL function is used. ^A function implementation with a non-negative +** nArg parameter is a better match than a function implementation with +** a negative nArg. ^A function where the preferred text encoding +** matches the database encoding is a better +** match than a function where the encoding is different. +** ^A function where the encoding difference is between UTF16le and UTF16be +** is a closer match than a function where the encoding difference is +** between UTF8 and UTF16. +** +** ^Built-in functions may be overloaded by new application-defined functions. +** +** ^An application-defined function is permitted to call other +** SQLite interfaces. However, such calls must not +** close the database connection nor finalize or reset the prepared +** statement in which the function is running. +*/ +SQLITE_API int sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +SQLITE_API int sqlite3_create_function_v2( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int eTextRep, + void *pApp, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*), + void(*xDestroy)(void*) +); + +/* +** CAPI3REF: Text Encodings +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 +#define SQLITE_UTF16LE 2 +#define SQLITE_UTF16BE 3 +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* sqlite3_create_function only */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Deprecated Functions +** DEPRECATED +** +** These functions are [deprecated]. In order to maintain +** backwards compatibility with older code, these functions continue +** to be supported. However, new applications should avoid +** the use of these functions. To help encourage people to avoid +** using these functions, we are not going to tell you what they do. +*/ +#ifndef SQLITE_OMIT_DEPRECATED +SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void); +SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void); +SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int), + void*,sqlite3_int64); +#endif + +/* +** CAPI3REF: Obtaining SQL Function Parameter Values +** +** The C-language implementation of SQL functions and aggregates uses +** this set of interface routines to access the parameter values on +** the function or aggregate. +** +** The xFunc (for scalar functions) or xStep (for aggregates) parameters +** to [sqlite3_create_function()] and [sqlite3_create_function16()] +** define callbacks that implement the SQL functions and aggregates. +** The 3rd parameter to these callbacks is an array of pointers to +** [protected sqlite3_value] objects. There is one [sqlite3_value] object for +** each parameter to the SQL function. These routines are used to +** extract values from the [sqlite3_value] objects. +** +** These routines work only with [protected sqlite3_value] objects. +** Any attempt to use these routines on an [unprotected sqlite3_value] +** object results in undefined behavior. +** +** ^These routines work just like the corresponding [column access functions] +** except that these routines take a single [protected sqlite3_value] object +** pointer instead of a [sqlite3_stmt*] pointer and an integer column number. +** +** ^The sqlite3_value_text16() interface extracts a UTF-16 string +** in the native byte-order of the host machine. ^The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF-16 strings as big-endian and little-endian respectively. +** +** ^(The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words, if the value is a string that looks like a number) +** then the conversion is performed. Otherwise no conversion occurs. +** The [SQLITE_INTEGER | datatype] after conversion is returned.)^ +** +** Please pay particular attention to the fact that the pointer returned +** from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the [sqlite3_value*] parameters. +*/ +SQLITE_API const void *sqlite3_value_blob(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes(sqlite3_value*); +SQLITE_API int sqlite3_value_bytes16(sqlite3_value*); +SQLITE_API double sqlite3_value_double(sqlite3_value*); +SQLITE_API int sqlite3_value_int(sqlite3_value*); +SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*); +SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*); +SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*); +SQLITE_API int sqlite3_value_type(sqlite3_value*); +SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context +** +** Implementations of aggregate SQL functions use this +** routine to allocate memory for storing their state. +** +** ^The first time the sqlite3_aggregate_context(C,N) routine is called +** for a particular aggregate function, SQLite +** allocates N of memory, zeroes out that memory, and returns a pointer +** to the new memory. ^On second and subsequent calls to +** sqlite3_aggregate_context() for the same aggregate function instance, +** the same buffer is returned. Sqlite3_aggregate_context() is normally +** called once for each invocation of the xStep callback and then one +** last time when the xFinal callback is invoked. ^(When no rows match +** an aggregate query, the xStep() callback of the aggregate function +** implementation is never called and xFinal() is called exactly once. +** In those cases, sqlite3_aggregate_context() might be called for the +** first time from within xFinal().)^ +** +** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer +** when first called if N is less than or equal to zero or if a memory +** allocate error occurs. +** +** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is +** determined by the N parameter on first successful call. Changing the +** value of N in subsequent call to sqlite3_aggregate_context() within +** the same aggregate function instance will not resize the memory +** allocation.)^ Within the xFinal callback, it is customary to set +** N=0 in calls to sqlite3_aggregate_context(C,N) so that no +** pointless memory allocations occur. +** +** ^SQLite automatically frees the memory allocated by +** sqlite3_aggregate_context() when the aggregate query concludes. +** +** The first parameter must be a copy of the +** [sqlite3_context | SQL function context] that is the first parameter +** to the xStep or xFinal callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions +** +** ^The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +** +** This routine must be called from the same thread in which +** the application-defined function is running. +*/ +SQLITE_API void *sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Database Connection For Functions +** +** ^The sqlite3_context_db_handle() interface returns a copy of +** the pointer to the [database connection] (the 1st parameter) +** of the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. +*/ +SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data +** +** The following two functions may be used by scalar SQL functions to +** associate metadata with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated metadata may be preserved. This may +** be used, for example, to add a regular-expression matching scalar +** function. The compiled version of the regular expression is stored as +** metadata associated with the SQL value passed as the regular expression +** pattern. The compiled regular expression can be reused on multiple +** invocations of the same function so that the original pattern string +** does not need to be recompiled on each invocation. +** +** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata +** associated by the sqlite3_set_auxdata() function with the Nth argument +** value to the application-defined function. ^If no metadata has been ever +** been set for the Nth argument of the function, or if the corresponding +** function parameter has changed since the meta-data was set, +** then sqlite3_get_auxdata() returns a NULL pointer. +** +** ^The sqlite3_set_auxdata() interface saves the metadata +** pointed to by its 3rd parameter as the metadata for the N-th +** argument of the application-defined function. Subsequent +** calls to sqlite3_get_auxdata() might return this data, if it has +** not been destroyed. +** ^If it is not NULL, SQLite will invoke the destructor +** function given by the 4th parameter to sqlite3_set_auxdata() on +** the metadata when the corresponding function parameter changes +** or when the SQL statement completes, whichever comes first. +** +** SQLite is free to call the destructor and drop metadata on any +** parameter of any function at any time. ^The only guarantee is that +** the destructor will be called before the metadata is dropped. +** +** ^(In practice, metadata is preserved between function calls for +** expressions that are constant at compile time. This includes literal +** values and [parameters].)^ +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N); +SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior +** +** These are special values for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. ^If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. ^The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. See ticket #2191. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the [parameter binding] family of +** functions used to bind values to host parameters in prepared statements. +** Refer to the [SQL parameter] documentation for additional information. +** +** ^The sqlite3_result_blob() interface sets the result from +** an application-defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** +** ^The sqlite3_result_zeroblob() interfaces set the result of +** the application-defined function to be a BLOB containing all zero +** bytes and N bytes in size, where N is the value of the 2nd parameter. +** +** ^The sqlite3_result_double() interface sets the result from +** an application-defined function to be a floating point value specified +** by its 2nd argument. +** +** ^The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** ^SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. ^SQLite interprets the error +** message string from sqlite3_result_error() as UTF-8. ^SQLite +** interprets the string from sqlite3_result_error16() as UTF-16 in native +** byte order. ^If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** ^If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** ^The sqlite3_result_error() and sqlite3_result_error16() +** routines make a private copy of the error message text before +** they return. Hence, the calling function can deallocate or +** modify the text after they return without harm. +** ^The sqlite3_result_error_code() function changes the error code +** returned by SQLite as a result of an error in a function. ^By default, +** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error() +** or sqlite3_result_error16() resets the error code to SQLITE_ERROR. +** +** ^The sqlite3_result_error_toobig() interface causes SQLite to throw an +** error indicating that a string or BLOB is too long to represent. +** +** ^The sqlite3_result_error_nomem() interface causes SQLite to throw an +** error indicating that a memory allocation failed. +** +** ^The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** ^The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** ^The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** ^The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** ^SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is negative, then SQLite takes result text from the 2nd parameter +** through the first zero character. +** ^If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. If the 3rd parameter is non-negative, then it +** must be the byte offset into the string where the NUL terminator would +** appear if the string where NUL terminated. If any NUL characters occur +** in the string at a byte offset that is less than the value of the 3rd +** parameter, then the resulting string will contain embedded NULs and the +** result of expressions operating on strings with embedded NULs is undefined. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or BLOB result when it has +** finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces or to +** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite +** assumes that the text or BLOB result is in constant space and does not +** copy the content of the parameter nor call a destructor on the content +** when it has finished using that result. +** ^If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained from +** from [sqlite3_malloc()] before it returns. +** +** ^The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy the +** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that the [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** ^A [protected sqlite3_value] object may always be used where an +** [unprotected sqlite3_value] object is required, so either +** kind of [sqlite3_value] object can be used with this interface. +** +** If these routines are called from within the different thread +** than the one containing the application-defined function that received +** the [sqlite3_context] pointer, the results are undefined. +*/ +SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_double(sqlite3_context*, double); +SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int); +SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int); +SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*); +SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*); +SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int(sqlite3_context*, int); +SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +SQLITE_API void sqlite3_result_null(sqlite3_context*); +SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*); +SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n); + +/* +** CAPI3REF: Define New Collating Sequences +** +** ^These functions add, remove, or modify a [collation] associated +** with the [database connection] specified as the first argument. +** +** ^The name of the collation is a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string in native byte order for sqlite3_create_collation16(). +** ^Collation names that compare equal according to [sqlite3_strnicmp()] are +** considered to be the same name. +** +** ^(The third argument (eTextRep) must be one of the constants: +**
    +**
  • [SQLITE_UTF8], +**
  • [SQLITE_UTF16LE], +**
  • [SQLITE_UTF16BE], +**
  • [SQLITE_UTF16], or +**
  • [SQLITE_UTF16_ALIGNED]. +**
)^ +** ^The eTextRep argument determines the encoding of strings passed +** to the collating function callback, xCallback. +** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep +** force strings to be UTF16 with native byte order. +** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin +** on an even byte address. +** +** ^The fourth argument, pArg, is an application data pointer that is passed +** through as the first argument to the collating function callback. +** +** ^The fifth argument, xCallback, is a pointer to the collating function. +** ^Multiple collating functions can be registered using the same name but +** with different eTextRep parameters and SQLite will use whichever +** function requires the least amount of data transformation. +** ^If the xCallback argument is NULL then the collating function is +** deleted. ^When all collating functions having the same name are deleted, +** that collation is no longer usable. +** +** ^The collating function callback is invoked with a copy of the pArg +** application data pointer and with two strings in the encoding specified +** by the eTextRep argument. The collating function must return an +** integer that is negative, zero, or positive +** if the first string is less than, equal to, or greater than the second, +** respectively. A collating function must always return the same answer +** given the same inputs. If two or more collating functions are registered +** to the same collation name (using different eTextRep values) then all +** must give an equivalent answer when invoked with equivalent strings. +** The collating function must obey the following properties for all +** strings A, B, and C: +** +**
    +**
  1. If A==B then B==A. +**
  2. If A==B and B==C then A==C. +**
  3. If A<B THEN B>A. +**
  4. If A<B and B<C then A<C. +**
+** +** If a collating function fails any of the above constraints and that +** collating function is registered and used, then the behavior of SQLite +** is undefined. +** +** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** with the addition that the xDestroy callback is invoked on pArg when +** the collating function is deleted. +** ^Collating functions are deleted when they are overridden by later +** calls to the collation creation functions or when the +** [database connection] is closed using [sqlite3_close()]. +** +** ^The xDestroy callback is not called if the +** sqlite3_create_collation_v2() function fails. Applications that invoke +** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should +** check the return code and dispose of the application data pointer +** themselves rather than expecting SQLite to deal with it for them. +** This is different from every other SQLite interface. The inconsistency +** is unfortunate but cannot be changed without breaking backwards +** compatibility. +** +** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()]. +*/ +SQLITE_API int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); +SQLITE_API int sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +SQLITE_API int sqlite3_create_collation16( + sqlite3*, + const void *zName, + int eTextRep, + void *pArg, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks +** +** ^To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** [database connection] to be invoked whenever an undefined collation +** sequence is required. +** +** ^If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. ^If sqlite3_collation_needed16() is used, +** the names are passed as UTF-16 in machine native byte order. +** ^A call to either function replaces the existing collation-needed callback. +** +** ^(When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE], +** or [SQLITE_UTF16LE], indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence.)^ +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +SQLITE_API int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +SQLITE_API int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +#ifdef SQLITE_HAS_CODEC +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +SQLITE_API int sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +SQLITE_API int sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); + +/* +** Specify the activation key for a SEE database. Unless +** activated, none of the SEE routines will work. +*/ +SQLITE_API void sqlite3_activate_see( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +#ifdef SQLITE_ENABLE_CEROD +/* +** Specify the activation key for a CEROD database. Unless +** activated, none of the CEROD routines will work. +*/ +SQLITE_API void sqlite3_activate_cerod( + const char *zPassPhrase /* Activation phrase */ +); +#endif + +/* +** CAPI3REF: Suspend Execution For A Short Time +** +** The sqlite3_sleep() function causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** ^SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. If the xSleep() method +** of the default VFS is not implemented correctly, or not implemented at +** all, then the behavior of sqlite3_sleep() may deviate from the description +** in the previous paragraphs. +*/ +SQLITE_API int sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all temporary files +** created by SQLite when using a built-in [sqlite3_vfs | VFS] +** will be placed in that directory.)^ ^If this variable +** is a NULL pointer, then SQLite performs a search for an appropriate +** temporary file directory. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [temp_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [temp_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [temp_store_directory pragma] should be avoided. +** +** Note to Windows Runtime users: The temporary directory must be set +** prior to calling [sqlite3_open] or [sqlite3_open_v2]. Otherwise, various +** features that require the use of temporary files may fail. Here is an +** example of how to do this using C++ with the Windows Runtime: +** +** 
+** LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
+**       TemporaryFolder->Path->Data();
+** char zPathBuf[MAX_PATH + 1];
+** memset(zPathBuf, 0, sizeof(zPathBuf));
+** WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
+**       NULL, NULL);
+** sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);
+**
+*/ +SQLITE_API char *sqlite3_temp_directory; + +/* +** CAPI3REF: Name Of The Folder Holding Database Files +** +** ^(If this global variable is made to point to a string which is +** the name of a folder (a.k.a. directory), then all database files +** specified with a relative pathname and created or accessed by +** SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed +** to be relative to that directory.)^ ^If this variable is a NULL +** pointer, then SQLite assumes that all database files specified +** with a relative pathname are relative to the current directory +** for the process. Only the windows VFS makes use of this global +** variable; it is ignored by the unix VFS. +** +** Changing the value of this variable while a database connection is +** open can result in a corrupt database. +** +** It is not safe to read or modify this variable in more than one +** thread at a time. It is not safe to read or modify this variable +** if a [database connection] is being used at the same time in a separate +** thread. +** It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been called and that this variable remain unchanged +** thereafter. +** +** ^The [data_store_directory pragma] may modify this variable and cause +** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore, +** the [data_store_directory pragma] always assumes that any string +** that this variable points to is held in memory obtained from +** [sqlite3_malloc] and the pragma may attempt to free that memory +** using [sqlite3_free]. +** Hence, if this variable is modified directly, either it should be +** made NULL or made to point to memory obtained from [sqlite3_malloc] +** or else the use of the [data_store_directory pragma] should be avoided. +*/ +SQLITE_API char *sqlite3_data_directory; + +/* +** CAPI3REF: Test For Auto-Commit Mode +** KEYWORDS: {autocommit mode} +** +** ^The sqlite3_get_autocommit() interface returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. ^Autocommit mode is on by default. +** ^Autocommit mode is disabled by a [BEGIN] statement. +** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK]. +** +** If certain kinds of errors occur on a statement within a multi-statement +** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. The only way to +** find out whether SQLite automatically rolled back the transaction after +** an error is to use this function. +** +** If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. +*/ +SQLITE_API int sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement +** +** ^The sqlite3_db_handle interface returns the [database connection] handle +** to which a [prepared statement] belongs. ^The [database connection] +** returned by sqlite3_db_handle is the same [database connection] +** that was the first argument +** to the [sqlite3_prepare_v2()] call (or its variants) that was used to +** create the statement in the first place. +*/ +SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + +/* +** CAPI3REF: Return The Filename For A Database Connection +** +** ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename +** associated with database N of connection D. ^The main database file +** has the name "main". If there is no attached database N on the database +** connection D, or if database N is a temporary or in-memory database, then +** a NULL pointer is returned. +** +** ^The filename returned by this function is the output of the +** xFullPathname method of the [VFS]. ^In other words, the filename +** will be an absolute pathname, even if the filename used +** to open the database originally was a URI or relative pathname. +*/ +SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Determine if a database is read-only +** +** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N +** of connection D is read-only, 0 if it is read/write, or -1 if N is not +** the name of a database on connection D. +*/ +SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName); + +/* +** CAPI3REF: Find the next prepared statement +** +** ^This interface returns a pointer to the next [prepared statement] after +** pStmt associated with the [database connection] pDb. ^If pStmt is NULL +** then this interface returns a pointer to the first prepared statement +** associated with the database connection pDb. ^If no prepared statement +** satisfies the conditions of this routine, it returns NULL. +** +** The [database connection] pointer D in a call to +** [sqlite3_next_stmt(D,S)] must refer to an open database +** connection and in particular must not be a NULL pointer. +*/ +SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks +** +** ^The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is [COMMIT | committed]. +** ^Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** ^The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is [ROLLBACK | rolled back]. +** ^Any callback set by a previous call to sqlite3_rollback_hook() +** for the same database connection is overridden. +** ^The pArg argument is passed through to the callback. +** ^If the callback on a commit hook function returns non-zero, +** then the commit is converted into a rollback. +** +** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions +** return the P argument from the previous call of the same function +** on the same [database connection] D, or NULL for +** the first call for each function on D. +** +** The commit and rollback hook callbacks are not reentrant. +** The callback implementation must not do anything that will modify +** the database connection that invoked the callback. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the commit +** or rollback hook in the first place. +** Note that running any other SQL statements, including SELECT statements, +** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify +** the database connections for the meaning of "modify" in this paragraph. +** +** ^Registering a NULL function disables the callback. +** +** ^When the commit hook callback routine returns zero, the [COMMIT] +** operation is allowed to continue normally. ^If the commit hook +** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK]. +** ^The rollback hook is invoked on a rollback that results from a commit +** hook returning non-zero, just as it would be with any other rollback. +** +** ^For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** ^The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** +** See also the [sqlite3_update_hook()] interface. +*/ +SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Data Change Notification Callbacks +** +** ^The sqlite3_update_hook() interface registers a callback function +** with the [database connection] identified by the first argument +** to be invoked whenever a row is updated, inserted or deleted. +** ^Any callback set by a previous call to this function +** for the same database connection is overridden. +** +** ^The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted. +** ^The first argument to the callback is a copy of the third argument +** to sqlite3_update_hook(). +** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE], +** or [SQLITE_UPDATE], depending on the operation that caused the callback +** to be invoked. +** ^The third and fourth arguments to the callback contain pointers to the +** database and table name containing the affected row. +** ^The final callback parameter is the [rowid] of the row. +** ^In the case of an update, this is the [rowid] after the update takes place. +** +** ^(The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_master and sqlite_sequence).)^ +** +** ^In the current implementation, the update hook +** is not invoked when duplication rows are deleted because of an +** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook +** invoked when rows are deleted using the [truncate optimization]. +** The exceptions defined in this paragraph might change in a future +** release of SQLite. +** +** The update hook implementation must not do anything that will modify +** the database connection that invoked the update hook. Any actions +** to modify the database connection must be deferred until after the +** completion of the [sqlite3_step()] call that triggered the update hook. +** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their +** database connections for the meaning of "modify" in this paragraph. +** +** ^The sqlite3_update_hook(D,C,P) function +** returns the P argument from the previous call +** on the same [database connection] D, or NULL for +** the first call on D. +** +** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()] +** interfaces. +*/ +SQLITE_API void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache +** +** ^(This routine enables or disables the sharing of the database cache +** and schema data structures between [database connection | connections] +** to the same database. Sharing is enabled if the argument is true +** and disabled if the argument is false.)^ +** +** ^Cache sharing is enabled and disabled for an entire process. +** This is a change as of SQLite version 3.5.0. In prior versions of SQLite, +** sharing was enabled or disabled for each thread separately. +** +** ^(The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** Existing database connections continue use the sharing mode +** that was in effect at the time they were opened.)^ +** +** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled +** successfully. An [error code] is returned otherwise.)^ +** +** ^Shared cache is disabled by default. But this might change in +** future releases of SQLite. Applications that care about shared +** cache setting should set it explicitly. +** +** This interface is threadsafe on processors where writing a +** 32-bit integer is atomic. +** +** See Also: [SQLite Shared-Cache Mode] +*/ +SQLITE_API int sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory +** +** ^The sqlite3_release_memory() interface attempts to free N bytes +** of heap memory by deallocating non-essential memory allocations +** held by the database library. Memory used to cache database +** pages to improve performance is an example of non-essential memory. +** ^sqlite3_release_memory() returns the number of bytes actually freed, +** which might be more or less than the amount requested. +** ^The sqlite3_release_memory() routine is a no-op returning zero +** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** See also: [sqlite3_db_release_memory()] +*/ +SQLITE_API int sqlite3_release_memory(int); + +/* +** CAPI3REF: Free Memory Used By A Database Connection +** +** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap +** memory as possible from database connection D. Unlike the +** [sqlite3_release_memory()] interface, this interface is effect even +** when then [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is +** omitted. +** +** See also: [sqlite3_release_memory()] +*/ +SQLITE_API int sqlite3_db_release_memory(sqlite3*); + +/* +** CAPI3REF: Impose A Limit On Heap Size +** +** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the +** soft limit on the amount of heap memory that may be allocated by SQLite. +** ^SQLite strives to keep heap memory utilization below the soft heap +** limit by reducing the number of pages held in the page cache +** as heap memory usages approaches the limit. +** ^The soft heap limit is "soft" because even though SQLite strives to stay +** below the limit, it will exceed the limit rather than generate +** an [SQLITE_NOMEM] error. In other words, the soft heap limit +** is advisory only. +** +** ^The return value from sqlite3_soft_heap_limit64() is the size of +** the soft heap limit prior to the call, or negative in the case of an +** error. ^If the argument N is negative +** then no change is made to the soft heap limit. Hence, the current +** size of the soft heap limit can be determined by invoking +** sqlite3_soft_heap_limit64() with a negative argument. +** +** ^If the argument N is zero then the soft heap limit is disabled. +** +** ^(The soft heap limit is not enforced in the current implementation +** if one or more of following conditions are true: +** +**
    +**
  • The soft heap limit is set to zero. +**
  • Memory accounting is disabled using a combination of the +** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and +** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option. +**
  • An alternative page cache implementation is specified using +** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...). +**
  • The page cache allocates from its own memory pool supplied +** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than +** from the heap. +**
)^ +** +** Beginning with SQLite version 3.7.3, the soft heap limit is enforced +** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT] +** compile-time option is invoked. With [SQLITE_ENABLE_MEMORY_MANAGEMENT], +** the soft heap limit is enforced on every memory allocation. Without +** [SQLITE_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced +** when memory is allocated by the page cache. Testing suggests that because +** the page cache is the predominate memory user in SQLite, most +** applications will achieve adequate soft heap limit enforcement without +** the use of [SQLITE_ENABLE_MEMORY_MANAGEMENT]. +** +** The circumstances under which SQLite will enforce the soft heap limit may +** changes in future releases of SQLite. +*/ +SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N); + +/* +** CAPI3REF: Deprecated Soft Heap Limit Interface +** DEPRECATED +** +** This is a deprecated version of the [sqlite3_soft_heap_limit64()] +** interface. This routine is provided for historical compatibility +** only. All new applications should use the +** [sqlite3_soft_heap_limit64()] interface rather than this one. +*/ +SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N); + + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table +** +** ^This routine returns metadata about a specific column of a specific +** database table accessible using the [database connection] handle +** passed as the first function argument. +** +** ^The column is identified by the second, third and fourth parameters to +** this function. ^The second parameter is either the name of the database +** (i.e. "main", "temp", or an attached database) containing the specified +** table or NULL. ^If it is NULL, then all attached databases are searched +** for the table using the same algorithm used by the database engine to +** resolve unqualified table references. +** +** ^The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. Neither of these parameters +** may be NULL. +** +** ^Metadata is returned by writing to the memory locations passed as the 5th +** and subsequent parameters to this function. ^Any of these arguments may be +** NULL, in which case the corresponding element of metadata is omitted. +** +** ^(
+** +**
Parameter Output
Type 		Description +** +**
5th const char* Data type +**
6th const char* Name of default collation sequence +**
7th int True if column has a NOT NULL constraint +**
8th int True if column is part of the PRIMARY KEY +**
9th int True if column is [AUTOINCREMENT] +**
+**
)^ +** +** ^The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid only until the next +** call to any SQLite API function. +** +** ^If the specified table is actually a view, an [error code] is returned. +** +** ^If the specified column is "rowid", "oid" or "_rowid_" and an +** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. ^(If there is no +** explicitly declared [INTEGER PRIMARY KEY] column, then the output +** parameters are set as follows: +** +** 
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
)^ +** +** ^(This function may load one or more schemas from database files. If an +** error occurs during this process, or if the requested table or column +** cannot be found, an [error code] is returned and an error message left +** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^ +** +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined. +*/ +SQLITE_API int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension +** +** ^This interface loads an SQLite extension library from the named file. +** +** ^The sqlite3_load_extension() interface attempts to load an +** SQLite extension library contained in the file zFile. +** +** ^The entry point is zProc. +** ^zProc may be 0, in which case the name of the entry point +** defaults to "sqlite3_extension_init". +** ^The sqlite3_load_extension() interface returns +** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** ^If an error occurs and pzErrMsg is not 0, then the +** [sqlite3_load_extension()] interface shall attempt to +** fill *pzErrMsg with error message text stored in memory +** obtained from [sqlite3_malloc()]. The calling function +** should free this memory by calling [sqlite3_free()]. +** +** ^Extension loading must be enabled using +** [sqlite3_enable_load_extension()] prior to calling this API, +** otherwise an error will be returned. +** +** See also the [load_extension() SQL function]. +*/ +SQLITE_API int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading +** +** ^So as not to open security holes in older applications that are +** unprepared to deal with extension loading, and as a means of disabling +** extension loading while evaluating user-entered SQL, the following API +** is provided to turn the [sqlite3_load_extension()] mechanism on and off. +** +** ^Extension loading is off by default. See ticket #1863. +** ^Call the sqlite3_enable_load_extension() routine with onoff==1 +** to turn extension loading on and call it with onoff==0 to turn +** it back off again. +*/ +SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Automatically Load Statically Linked Extensions +** +** ^This interface causes the xEntryPoint() function to be invoked for +** each new [database connection] that is created. The idea here is that +** xEntryPoint() is the entry point for a statically linked SQLite extension +** that is to be automatically loaded into all new database connections. +** +** ^(Even though the function prototype shows that xEntryPoint() takes +** no arguments and returns void, SQLite invokes xEntryPoint() with three +** arguments and expects and integer result as if the signature of the +** entry point where as follows: +** +** 
+**    int xEntryPoint(
+**      sqlite3 *db,
+**      const char **pzErrMsg,
+**      const struct sqlite3_api_routines *pThunk
+**    );
+**
)^ +** +** If the xEntryPoint routine encounters an error, it should make *pzErrMsg +** point to an appropriate error message (obtained from [sqlite3_mprintf()]) +** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg +** is NULL before calling the xEntryPoint(). ^SQLite will invoke +** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any +** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()], +** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail. +** +** ^Calling sqlite3_auto_extension(X) with an entry point X that is already +** on the list of automatic extensions is a harmless no-op. ^No entry point +** will be called more than once for each database connection that is opened. +** +** See also: [sqlite3_reset_auto_extension()]. +*/ +SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void)); + +/* +** CAPI3REF: Reset Automatic Extension Loading +** +** ^This interface disables all automatic extensions previously +** registered using [sqlite3_auto_extension()]. +*/ +SQLITE_API void sqlite3_reset_auto_extension(void); + +/* +** The interface to the virtual-table mechanism is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** CAPI3REF: Virtual Table Object +** KEYWORDS: sqlite3_module {virtual table module} +** +** This structure, sometimes called a "virtual table module", +** defines the implementation of a [virtual tables]. +** This structure consists mostly of methods for the module. +** +** ^A virtual table module is created by filling in a persistent +** instance of this structure and passing a pointer to that instance +** to [sqlite3_create_module()] or [sqlite3_create_module_v2()]. +** ^The registration remains valid until it is replaced by a different +** module or until the [database connection] closes. The content +** of this structure must not change while it is registered with +** any database connection. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); + /* The methods above are in version 1 of the sqlite_module object. Those + ** below are for version 2 and greater. */ + int (*xSavepoint)(sqlite3_vtab *pVTab, int); + int (*xRelease)(sqlite3_vtab *pVTab, int); + int (*xRollbackTo)(sqlite3_vtab *pVTab, int); +}; + +/* +** CAPI3REF: Virtual Table Indexing Information +** KEYWORDS: sqlite3_index_info +** +** The sqlite3_index_info structure and its substructures is used as part +** of the [virtual table] interface to +** pass information into and receive the reply from the [xBestIndex] +** method of a [virtual table module]. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** ^(The aConstraint[] array records WHERE clause constraints of the form: +** +**
column OP expr
+** +** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +** stored in aConstraint[].op using one of the +** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +** ^(The index of the column is stored in +** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot.)^ +** +** ^The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** ^The aConstraint[] array only reports WHERE clause terms that are +** relevant to the particular virtual table being queried. +** +** ^Information about the ORDER BY clause is stored in aOrderBy[]. +** ^Each term of aOrderBy records a column of the ORDER BY clause. +** +** The [xBestIndex] method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. ^If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and is not checked again by SQLite.)^ +** +** ^The idxNum and idxPtr values are recorded and passed into the +** [xFilter] method. +** ^[sqlite3_free()] is used to free idxPtr if and only if +** needToFreeIdxPtr is true. +** +** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** ^The estimatedCost value is an estimate of the cost of doing the +** particular lookup. A full scan of a table with N entries should have +** a cost of N. A binary search of a table of N entries should have a +** cost of approximately log(N). +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column on left-hand side of constraint */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ +}; + +/* +** CAPI3REF: Virtual Table Constraint Operator Codes +** +** These macros defined the allowed values for the +** [sqlite3_index_info].aConstraint[].op field. Each value represents +** an operator that is part of a constraint term in the wHERE clause of +** a query that uses a [virtual table]. +*/ +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 + +/* +** CAPI3REF: Register A Virtual Table Implementation +** +** ^These routines are used to register a new [virtual table module] name. +** ^Module names must be registered before +** creating a new [virtual table] using the module and before using a +** preexisting [virtual table] for the module. +** +** ^The module name is registered on the [database connection] specified +** by the first parameter. ^The name of the module is given by the +** second parameter. ^The third parameter is a pointer to +** the implementation of the [virtual table module]. ^The fourth +** parameter is an arbitrary client data pointer that is passed through +** into the [xCreate] and [xConnect] methods of the virtual table module +** when a new virtual table is be being created or reinitialized. +** +** ^The sqlite3_create_module_v2() interface has a fifth parameter which +** is a pointer to a destructor for the pClientData. ^SQLite will +** invoke the destructor function (if it is not NULL) when SQLite +** no longer needs the pClientData pointer. ^The destructor will also +** be invoked if the call to sqlite3_create_module_v2() fails. +** ^The sqlite3_create_module() +** interface is equivalent to sqlite3_create_module_v2() with a NULL +** destructor. +*/ +SQLITE_API int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData /* Client data for xCreate/xConnect */ +); +SQLITE_API int sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *p, /* Methods for the module */ + void *pClientData, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** CAPI3REF: Virtual Table Instance Object +** KEYWORDS: sqlite3_vtab +** +** Every [virtual table module] implementation uses a subclass +** of this object to describe a particular instance +** of the [virtual table]. Each subclass will +** be tailored to the specific needs of the module implementation. +** The purpose of this superclass is to define certain fields that are +** common to all module implementations. +** +** ^Virtual tables methods can set an error message by assigning a +** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should +** take care that any prior string is freed by a call to [sqlite3_free()] +** prior to assigning a new string to zErrMsg. ^After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* NO LONGER USED */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Virtual Table Cursor Object +** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor} +** +** Every [virtual table module] implementation uses a subclass of the +** following structure to describe cursors that point into the +** [virtual table] and are used +** to loop through the virtual table. Cursors are created using the +** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed +** by the [sqlite3_module.xClose | xClose] method. Cursors are used +** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods +** of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** CAPI3REF: Declare The Schema Of A Virtual Table +** +** ^The [xCreate] and [xConnect] methods of a +** [virtual table module] call this interface +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL); + +/* +** CAPI3REF: Overload A Function For A Virtual Table +** +** ^(Virtual tables can provide alternative implementations of functions +** using the [xFindFunction] method of the [virtual table module]. +** But global versions of those functions +** must exist in order to be overloaded.)^ +** +** ^(This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created.)^ ^The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a placeholder function that can be overloaded +** by a [virtual table]. +*/ +SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** The interface to the virtual-table mechanism defined above (back up +** to a comment remarkably similar to this one) is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** CAPI3REF: A Handle To An Open BLOB +** KEYWORDS: {BLOB handle} {BLOB handles} +** +** An instance of this object represents an open BLOB on which +** [sqlite3_blob_open | incremental BLOB I/O] can be performed. +** ^Objects of this type are created by [sqlite3_blob_open()] +** and destroyed by [sqlite3_blob_close()]. +** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the BLOB. +** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O +** +** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located +** in row iRow, column zColumn, table zTable in database zDb; +** in other words, the same BLOB that would be selected by: +** +** 
+**     SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
+**
)^ +** +** ^If the flags parameter is non-zero, then the BLOB is opened for read +** and write access. ^If it is zero, the BLOB is opened for read access. +** ^It is not possible to open a column that is part of an index or primary +** key for writing. ^If [foreign key constraints] are enabled, it is +** not possible to open a column that is part of a [child key] for writing. +** +** ^Note that the database name is not the filename that contains +** the database but rather the symbolic name of the database that +** appears after the AS keyword when the database is connected using [ATTACH]. +** ^For the main database file, the database name is "main". +** ^For TEMP tables, the database name is "temp". +** +** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written +** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set +** to be a null pointer.)^ +** ^This function sets the [database connection] error code and message +** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related +** functions. ^Note that the *ppBlob variable is always initialized in a +** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob +** regardless of the success or failure of this routine. +** +** ^(If the row that a BLOB handle points to is modified by an +** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects +** then the BLOB handle is marked as "expired". +** This is true if any column of the row is changed, even a column +** other than the one the BLOB handle is open on.)^ +** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for +** an expired BLOB handle fail with a return code of [SQLITE_ABORT]. +** ^(Changes written into a BLOB prior to the BLOB expiring are not +** rolled back by the expiration of the BLOB. Such changes will eventually +** commit if the transaction continues to completion.)^ +** +** ^Use the [sqlite3_blob_bytes()] interface to determine the size of +** the opened blob. ^The size of a blob may not be changed by this +** interface. Use the [UPDATE] SQL command to change the size of a +** blob. +** +** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces +** and the built-in [zeroblob] SQL function can be used, if desired, +** to create an empty, zero-filled blob in which to read or write using +** this interface. +** +** To avoid a resource leak, every open [BLOB handle] should eventually +** be released by a call to [sqlite3_blob_close()]. +*/ +SQLITE_API int sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Move a BLOB Handle to a New Row +** +** ^This function is used to move an existing blob handle so that it points +** to a different row of the same database table. ^The new row is identified +** by the rowid value passed as the second argument. Only the row can be +** changed. ^The database, table and column on which the blob handle is open +** remain the same. Moving an existing blob handle to a new row can be +** faster than closing the existing handle and opening a new one. +** +** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] - +** it must exist and there must be either a blob or text value stored in +** the nominated column.)^ ^If the new row is not present in the table, or if +** it does not contain a blob or text value, or if another error occurs, an +** SQLite error code is returned and the blob handle is considered aborted. +** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or +** [sqlite3_blob_reopen()] on an aborted blob handle immediately return +** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle +** always returns zero. +** +** ^This function sets the database handle error code and message. +*/ +SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64); + +/* +** CAPI3REF: Close A BLOB Handle +** +** ^Closes an open [BLOB handle]. +** +** ^Closing a BLOB shall cause the current transaction to commit +** if there are no other BLOBs, no pending prepared statements, and the +** database connection is in [autocommit mode]. +** ^If any writes were made to the BLOB, they might be held in cache +** until the close operation if they will fit. +** +** ^(Closing the BLOB often forces the changes +** out to disk and so if any I/O errors occur, they will likely occur +** at the time when the BLOB is closed. Any errors that occur during +** closing are reported as a non-zero return value.)^ +** +** ^(The BLOB is closed unconditionally. Even if this routine returns +** an error code, the BLOB is still closed.)^ +** +** ^Calling this routine with a null pointer (such as would be returned +** by a failed call to [sqlite3_blob_open()]) is a harmless no-op. +*/ +SQLITE_API int sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB +** +** ^Returns the size in bytes of the BLOB accessible via the +** successfully opened [BLOB handle] in its only argument. ^The +** incremental blob I/O routines can only read or overwriting existing +** blob content; they cannot change the size of a blob. +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +*/ +SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally +** +** ^(This function is used to read data from an open [BLOB handle] into a +** caller-supplied buffer. N bytes of data are copied into buffer Z +** from the open BLOB, starting at offset iOffset.)^ +** +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is +** less than zero, [SQLITE_ERROR] is returned and no data is read. +** ^The size of the blob (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to read from an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. +** +** ^(On success, sqlite3_blob_read() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_write()]. +*/ +SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally +** +** ^This function is used to write data into an open [BLOB handle] from a +** caller-supplied buffer. ^N bytes of data are copied from the buffer Z +** into the open BLOB, starting at offset iOffset. +** +** ^If the [BLOB handle] passed as the first argument was not opened for +** writing (the flags parameter to [sqlite3_blob_open()] was zero), +** this function returns [SQLITE_READONLY]. +** +** ^This function may only modify the contents of the BLOB; it is +** not possible to increase the size of a BLOB using this API. +** ^If offset iOffset is less than N bytes from the end of the BLOB, +** [SQLITE_ERROR] is returned and no data is written. ^If N is +** less than zero [SQLITE_ERROR] is returned and no data is written. +** The size of the BLOB (and hence the maximum value of N+iOffset) +** can be determined using the [sqlite3_blob_bytes()] interface. +** +** ^An attempt to write to an expired [BLOB handle] fails with an +** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred +** before the [BLOB handle] expired are not rolled back by the +** expiration of the handle, though of course those changes might +** have been overwritten by the statement that expired the BLOB handle +** or by other independent statements. +** +** ^(On success, sqlite3_blob_write() returns SQLITE_OK. +** Otherwise, an [error code] or an [extended error code] is returned.)^ +** +** This routine only works on a [BLOB handle] which has been created +** by a prior successful call to [sqlite3_blob_open()] and which has not +** been closed by [sqlite3_blob_close()]. Passing any other pointer in +** to this routine results in undefined and probably undesirable behavior. +** +** See also: [sqlite3_blob_read()]. +*/ +SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most SQLite builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name. +** ^Names are case sensitive. +** ^Names are zero-terminated UTF-8 strings. +** ^If there is no match, a NULL pointer is returned. +** ^If zVfsName is NULL then the default VFS is returned. +** +** ^New VFSes are registered with sqlite3_vfs_register(). +** ^Each new VFS becomes the default VFS if the makeDflt flag is set. +** ^The same VFS can be registered multiple times without injury. +** ^To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. If two different VFSes with the +** same name are registered, the behavior is undefined. If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** ^Unregister a VFS with the sqlite3_vfs_unregister() interface. +** ^(If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary.)^ +*/ +SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); +SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. ^(The following +** implementations are available in the SQLite core: +** +**
    +**
  • SQLITE_MUTEX_PTHREADS +**
  • SQLITE_MUTEX_W32 +**
  • SQLITE_MUTEX_NOOP +**
)^ +** +** ^The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. ^The SQLITE_MUTEX_PTHREADS and +** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix +** and Windows. +** +** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. In this case the +** application must supply a custom mutex implementation using the +** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function +** before calling sqlite3_initialize() or any other public sqlite3_ +** function that calls sqlite3_initialize().)^ +** +** ^The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. ^If it returns NULL +** that means that a mutex could not be allocated. ^SQLite +** will unwind its stack and return an error. ^(The argument +** to sqlite3_mutex_alloc() is one of these integer constants: +** +**
    +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MASTER +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_MEM2 +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
  • SQLITE_MUTEX_STATIC_LRU2 +**
)^ +** +** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) +** cause sqlite3_mutex_alloc() to create +** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. ^SQLite will only request a recursive mutex in +** cases where it really needs one. ^If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other +** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return +** a pointer to a static preexisting mutex. ^Six static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. ^But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. +** +** ^The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. ^SQLite is careful to deallocate every +** dynamic mutex that it allocates. The dynamic mutexes must not be in +** use when they are deallocated. Attempting to deallocate a static +** mutex results in undefined behavior. ^SQLite never deallocates +** a static mutex. +** +** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. ^If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK] +** upon successful entry. ^(Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter.)^ ^(If the same thread tries to enter any other +** kind of mutex more than once, the behavior is undefined. +** SQLite will never exhibit +** such behavior in its own use of mutexes.)^ +** +** ^(Some systems (for example, Windows 95) do not support the operation +** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() +** will always return SQLITE_BUSY. The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^ +** +** ^The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. ^(The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. SQLite will +** never do either.)^ +** +** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or +** sqlite3_mutex_leave() is a NULL pointer, then all three routines +** behave as no-ops. +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int); +SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*); +SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Methods Object +** +** An instance of this structure defines the low-level routines +** used to allocate and use mutexes. +** +** Usually, the default mutex implementations provided by SQLite are +** sufficient, however the user has the option of substituting a custom +** implementation for specialized deployments or systems for which SQLite +** does not provide a suitable implementation. In this case, the user +** creates and populates an instance of this structure to pass +** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +** Additionally, an instance of this structure can be used as an +** output variable when querying the system for the current mutex +** implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +** +** ^The xMutexInit method defined by this structure is invoked as +** part of system initialization by the sqlite3_initialize() function. +** ^The xMutexInit routine is called by SQLite exactly once for each +** effective call to [sqlite3_initialize()]. +** +** ^The xMutexEnd method defined by this structure is invoked as +** part of system shutdown by the sqlite3_shutdown() function. The +** implementation of this method is expected to release all outstanding +** resources obtained by the mutex methods implementation, especially +** those obtained by the xMutexInit method. ^The xMutexEnd() +** interface is invoked exactly once for each call to [sqlite3_shutdown()]. +** +** ^(The remaining seven methods defined by this structure (xMutexAlloc, +** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +** xMutexNotheld) implement the following interfaces (respectively): +** +**
    +**
  • [sqlite3_mutex_alloc()]
    • +**
  • [sqlite3_mutex_free()]
    • +**
  • [sqlite3_mutex_enter()]
    • +**
  • [sqlite3_mutex_try()]
    • +**
  • [sqlite3_mutex_leave()]
    • +**
  • [sqlite3_mutex_held()]
    • +**
  • [sqlite3_mutex_notheld()]
    • +**
)^ +** +** The only difference is that the public sqlite3_XXX functions enumerated +** above silently ignore any invocations that pass a NULL pointer instead +** of a valid mutex handle. The implementations of the methods defined +** by this structure are not required to handle this case, the results +** of passing a NULL pointer instead of a valid mutex handle are undefined +** (i.e. it is acceptable to provide an implementation that segfaults if +** it is passed a NULL pointer). +** +** The xMutexInit() method must be threadsafe. ^It must be harmless to +** invoke xMutexInit() multiple times within the same process and without +** intervening calls to xMutexEnd(). Second and subsequent calls to +** xMutexInit() must be no-ops. +** +** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory +** allocation for a static mutex. ^However xMutexAlloc() may use SQLite +** memory allocation for a fast or recursive mutex. +** +** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +** called, but only if the prior call to xMutexInit returned SQLITE_OK. +** If xMutexInit fails in any way, it is expected to clean up after itself +** prior to returning. +*/ +typedef struct sqlite3_mutex_methods sqlite3_mutex_methods; +struct sqlite3_mutex_methods { + int (*xMutexInit)(void); + int (*xMutexEnd)(void); + sqlite3_mutex *(*xMutexAlloc)(int); + void (*xMutexFree)(sqlite3_mutex *); + void (*xMutexEnter)(sqlite3_mutex *); + int (*xMutexTry)(sqlite3_mutex *); + void (*xMutexLeave)(sqlite3_mutex *); + int (*xMutexHeld)(sqlite3_mutex *); + int (*xMutexNotheld)(sqlite3_mutex *); +}; + +/* +** CAPI3REF: Mutex Verification Routines +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. ^The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. ^The SQLite core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. ^External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** ^These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. +** +** ^The implementation is not required to provide versions of these +** routines that actually work. If the implementation does not provide working +** versions of these routines, it should at least provide stubs that always +** return true so that one does not get spurious assertion failures. +** +** ^If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. ^The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +#ifndef NDEBUG +SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*); +SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*); +#endif + +/* +** CAPI3REF: Mutex Types +** +** The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. +** +** The set of static mutexes may change from one SQLite release to the +** next. Applications that override the built-in mutex logic must be +** prepared to accommodate additional static mutexes. +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MASTER 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ +#define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */ +#define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */ + +/* +** CAPI3REF: Retrieve the mutex for a database connection +** +** ^This interface returns a pointer the [sqlite3_mutex] object that +** serializes access to the [database connection] given in the argument +** when the [threading mode] is Serialized. +** ^If the [threading mode] is Single-thread or Multi-thread then this +** routine returns a NULL pointer. +*/ +SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*); + +/* +** CAPI3REF: Low-Level Control Of Database Files +** +** ^The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. ^The +** name of the database is "main" for the main database or "temp" for the +** TEMP database, or the name that appears after the AS keyword for +** databases that are added using the [ATTACH] SQL command. +** ^A NULL pointer can be used in place of "main" to refer to the +** main database file. +** ^The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. ^The return value of the xFileControl +** method becomes the return value of this routine. +** +** ^The SQLITE_FCNTL_FILE_POINTER value for the op parameter causes +** a pointer to the underlying [sqlite3_file] object to be written into +** the space pointed to by the 4th parameter. ^The SQLITE_FCNTL_FILE_POINTER +** case is a short-circuit path which does not actually invoke the +** underlying sqlite3_io_methods.xFileControl method. +** +** ^If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. ^This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. The underlying xFileControl method might +** also return SQLITE_ERROR. There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. +** +** See also: [SQLITE_FCNTL_LOCKSTATE] +*/ +SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/* +** CAPI3REF: Testing Interface +** +** ^The sqlite3_test_control() interface is used to read out internal +** state of SQLite and to inject faults into SQLite for testing +** purposes. ^The first parameter is an operation code that determines +** the number, meaning, and operation of all subsequent parameters. +** +** This interface is not for use by applications. It exists solely +** for verifying the correct operation of the SQLite library. Depending +** on how the SQLite library is compiled, this interface might not exist. +** +** The details of the operation codes, their meanings, the parameters +** they take, and what they do are all subject to change without notice. +** Unlike most of the SQLite API, this function is not guaranteed to +** operate consistently from one release to the next. +*/ +SQLITE_API int sqlite3_test_control(int op, ...); + +/* +** CAPI3REF: Testing Interface Operation Codes +** +** These constants are the valid operation code parameters used +** as the first argument to [sqlite3_test_control()]. +** +** These parameters and their meanings are subject to change +** without notice. These values are for testing purposes only. +** Applications should not use any of these parameters or the +** [sqlite3_test_control()] interface. +*/ +#define SQLITE_TESTCTRL_FIRST 5 +#define SQLITE_TESTCTRL_PRNG_SAVE 5 +#define SQLITE_TESTCTRL_PRNG_RESTORE 6 +#define SQLITE_TESTCTRL_PRNG_RESET 7 +#define SQLITE_TESTCTRL_BITVEC_TEST 8 +#define SQLITE_TESTCTRL_FAULT_INSTALL 9 +#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 +#define SQLITE_TESTCTRL_PENDING_BYTE 11 +#define SQLITE_TESTCTRL_ASSERT 12 +#define SQLITE_TESTCTRL_ALWAYS 13 +#define SQLITE_TESTCTRL_RESERVE 14 +#define SQLITE_TESTCTRL_OPTIMIZATIONS 15 +#define SQLITE_TESTCTRL_ISKEYWORD 16 +#define SQLITE_TESTCTRL_SCRATCHMALLOC 17 +#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 +#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 +#define SQLITE_TESTCTRL_LAST 19 + +/* +** CAPI3REF: SQLite Runtime Status +** +** ^This interface is used to retrieve runtime status information +** about the performance of SQLite, and optionally to reset various +** highwater marks. ^The first argument is an integer code for +** the specific parameter to measure. ^(Recognized integer codes +** are of the form [status parameters | SQLITE_STATUS_...].)^ +** ^The current value of the parameter is returned into *pCurrent. +** ^The highest recorded value is returned in *pHighwater. ^If the +** resetFlag is true, then the highest record value is reset after +** *pHighwater is written. ^(Some parameters do not record the highest +** value. For those parameters +** nothing is written into *pHighwater and the resetFlag is ignored.)^ +** ^(Other parameters record only the highwater mark and not the current +** value. For these latter parameters nothing is written into *pCurrent.)^ +** +** ^The sqlite3_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** This routine is threadsafe but is not atomic. This routine can be +** called while other threads are running the same or different SQLite +** interfaces. However the values returned in *pCurrent and +** *pHighwater reflect the status of SQLite at different points in time +** and it is possible that another thread might change the parameter +** in between the times when *pCurrent and *pHighwater are written. +** +** See also: [sqlite3_db_status()] +*/ +SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag); + + +/* +** CAPI3REF: Status Parameters +** KEYWORDS: {status parameters} +** +** These integer constants designate various run-time status parameters +** that can be returned by [sqlite3_status()]. +** +**
+** [[SQLITE_STATUS_MEMORY_USED]] ^(
SQLITE_STATUS_MEMORY_USED
+**
This parameter is the current amount of memory checked out +** using [sqlite3_malloc()], either directly or indirectly. The +** figure includes calls made to [sqlite3_malloc()] by the application +** and internal memory usage by the SQLite library. Scratch memory +** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache +** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in +** this parameter. The amount returned is the sum of the allocation +** sizes as reported by the xSize method in [sqlite3_mem_methods].
)^ +** +** [[SQLITE_STATUS_MALLOC_SIZE]] ^(
SQLITE_STATUS_MALLOC_SIZE
+**
This parameter records the largest memory allocation request +** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their +** internal equivalents). Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_MALLOC_COUNT]] ^(
SQLITE_STATUS_MALLOC_COUNT
+**
This parameter records the number of separate memory allocations +** currently checked out.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_USED]] ^(
SQLITE_STATUS_PAGECACHE_USED
+**
This parameter returns the number of pages used out of the +** [pagecache memory allocator] that was configured using +** [SQLITE_CONFIG_PAGECACHE]. The +** value returned is in pages, not in bytes.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]] +** ^(
SQLITE_STATUS_PAGECACHE_OVERFLOW
+**
This parameter returns the number of bytes of page cache +** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE] +** buffer and where forced to overflow to [sqlite3_malloc()]. The +** returned value includes allocations that overflowed because they +** where too large (they were larger than the "sz" parameter to +** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because +** no space was left in the page cache.
)^ +** +** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(
SQLITE_STATUS_PAGECACHE_SIZE
+**
This parameter records the largest memory allocation request +** handed to [pagecache memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_SCRATCH_USED]] ^(
SQLITE_STATUS_SCRATCH_USED
+**
This parameter returns the number of allocations used out of the +** [scratch memory allocator] configured using +** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not +** in bytes. Since a single thread may only have one scratch allocation +** outstanding at time, this parameter also reports the number of threads +** using scratch memory at the same time.
)^ +** +** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(
SQLITE_STATUS_SCRATCH_OVERFLOW
+**
This parameter returns the number of bytes of scratch memory +** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH] +** buffer and where forced to overflow to [sqlite3_malloc()]. The values +** returned include overflows because the requested allocation was too +** larger (that is, because the requested allocation was larger than the +** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer +** slots were available. +**
)^ +** +** [[SQLITE_STATUS_SCRATCH_SIZE]] ^(
SQLITE_STATUS_SCRATCH_SIZE
+**
This parameter records the largest memory allocation request +** handed to [scratch memory allocator]. Only the value returned in the +** *pHighwater parameter to [sqlite3_status()] is of interest. +** The value written into the *pCurrent parameter is undefined.
)^ +** +** [[SQLITE_STATUS_PARSER_STACK]] ^(
SQLITE_STATUS_PARSER_STACK
+**
This parameter records the deepest parser stack. It is only +** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].
)^ +**
+** +** New status parameters may be added from time to time. +*/ +#define SQLITE_STATUS_MEMORY_USED 0 +#define SQLITE_STATUS_PAGECACHE_USED 1 +#define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 +#define SQLITE_STATUS_SCRATCH_USED 3 +#define SQLITE_STATUS_SCRATCH_OVERFLOW 4 +#define SQLITE_STATUS_MALLOC_SIZE 5 +#define SQLITE_STATUS_PARSER_STACK 6 +#define SQLITE_STATUS_PAGECACHE_SIZE 7 +#define SQLITE_STATUS_SCRATCH_SIZE 8 +#define SQLITE_STATUS_MALLOC_COUNT 9 + +/* +** CAPI3REF: Database Connection Status +** +** ^This interface is used to retrieve runtime status information +** about a single [database connection]. ^The first argument is the +** database connection object to be interrogated. ^The second argument +** is an integer constant, taken from the set of +** [SQLITE_DBSTATUS options], that +** determines the parameter to interrogate. The set of +** [SQLITE_DBSTATUS options] is likely +** to grow in future releases of SQLite. +** +** ^The current value of the requested parameter is written into *pCur +** and the highest instantaneous value is written into *pHiwtr. ^If +** the resetFlg is true, then the highest instantaneous value is +** reset back down to the current value. +** +** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a +** non-zero [error code] on failure. +** +** See also: [sqlite3_status()] and [sqlite3_stmt_status()]. +*/ +SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg); + +/* +** CAPI3REF: Status Parameters for database connections +** KEYWORDS: {SQLITE_DBSTATUS options} +** +** These constants are the available integer "verbs" that can be passed as +** the second argument to the [sqlite3_db_status()] interface. +** +** New verbs may be added in future releases of SQLite. Existing verbs +** might be discontinued. Applications should check the return code from +** [sqlite3_db_status()] to make sure that the call worked. +** The [sqlite3_db_status()] interface will return a non-zero error code +** if a discontinued or unsupported verb is invoked. +** +**
+** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(
SQLITE_DBSTATUS_LOOKASIDE_USED
+**
This parameter returns the number of lookaside memory slots currently +** checked out.
)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(
SQLITE_DBSTATUS_LOOKASIDE_HIT
+**
This parameter returns the number malloc attempts that were +** satisfied using lookaside memory. Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to the amount of +** memory requested being larger than the lookaside slot size. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]] +** ^(
SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL
+**
This parameter returns the number malloc attempts that might have +** been satisfied using lookaside memory but failed due to all lookaside +** memory already being in use. +** Only the high-water value is meaningful; +** the current value is always zero.)^ +** +** [[SQLITE_DBSTATUS_CACHE_USED]] ^(
SQLITE_DBSTATUS_CACHE_USED
+**
This parameter returns the approximate number of of bytes of heap +** memory used by all pager caches associated with the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0. +** +** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(
SQLITE_DBSTATUS_SCHEMA_USED
+**
This parameter returns the approximate number of of bytes of heap +** memory used to store the schema for all databases associated +** with the connection - main, temp, and any [ATTACH]-ed databases.)^ +** ^The full amount of memory used by the schemas is reported, even if the +** schema memory is shared with other database connections due to +** [shared cache mode] being enabled. +** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0. +** +** [[SQLITE_DBSTATUS_STMT_USED]] ^(
SQLITE_DBSTATUS_STMT_USED
+**
This parameter returns the approximate number of of bytes of heap +** and lookaside memory used by all prepared statements associated with +** the database connection.)^ +** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(
SQLITE_DBSTATUS_CACHE_HIT
+**
This parameter returns the number of pager cache hits that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(
SQLITE_DBSTATUS_CACHE_MISS
+**
This parameter returns the number of pager cache misses that have +** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS +** is always 0. +**
+** +** [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(
SQLITE_DBSTATUS_CACHE_WRITE
+**
This parameter returns the number of dirty cache entries that have +** been written to disk. Specifically, the number of pages written to the +** wal file in wal mode databases, or the number of pages written to the +** database file in rollback mode databases. Any pages written as part of +** transaction rollback or database recovery operations are not included. +** If an IO or other error occurs while writing a page to disk, the effect +** on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The +** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0. +**
+**
+*/ +#define SQLITE_DBSTATUS_LOOKASIDE_USED 0 +#define SQLITE_DBSTATUS_CACHE_USED 1 +#define SQLITE_DBSTATUS_SCHEMA_USED 2 +#define SQLITE_DBSTATUS_STMT_USED 3 +#define SQLITE_DBSTATUS_LOOKASIDE_HIT 4 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5 +#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6 +#define SQLITE_DBSTATUS_CACHE_HIT 7 +#define SQLITE_DBSTATUS_CACHE_MISS 8 +#define SQLITE_DBSTATUS_CACHE_WRITE 9 +#define SQLITE_DBSTATUS_MAX 9 /* Largest defined DBSTATUS */ + + +/* +** CAPI3REF: Prepared Statement Status +** +** ^(Each prepared statement maintains various +** [SQLITE_STMTSTATUS counters] that measure the number +** of times it has performed specific operations.)^ These counters can +** be used to monitor the performance characteristics of the prepared +** statements. For example, if the number of table steps greatly exceeds +** the number of table searches or result rows, that would tend to indicate +** that the prepared statement is using a full table scan rather than +** an index. +** +** ^(This interface is used to retrieve and reset counter values from +** a [prepared statement]. The first argument is the prepared statement +** object to be interrogated. The second argument +** is an integer code for a specific [SQLITE_STMTSTATUS counter] +** to be interrogated.)^ +** ^The current value of the requested counter is returned. +** ^If the resetFlg is true, then the counter is reset to zero after this +** interface call returns. +** +** See also: [sqlite3_status()] and [sqlite3_db_status()]. +*/ +SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg); + +/* +** CAPI3REF: Status Parameters for prepared statements +** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters} +** +** These preprocessor macros define integer codes that name counter +** values associated with the [sqlite3_stmt_status()] interface. +** The meanings of the various counters are as follows: +** +**
+** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]]
SQLITE_STMTSTATUS_FULLSCAN_STEP
+**
^This is the number of times that SQLite has stepped forward in +** a table as part of a full table scan. Large numbers for this counter +** may indicate opportunities for performance improvement through +** careful use of indices.
+** +** [[SQLITE_STMTSTATUS_SORT]]
SQLITE_STMTSTATUS_SORT
+**
^This is the number of sort operations that have occurred. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance through careful use of indices.
+** +** [[SQLITE_STMTSTATUS_AUTOINDEX]]
SQLITE_STMTSTATUS_AUTOINDEX
+**
^This is the number of rows inserted into transient indices that +** were created automatically in order to help joins run faster. +** A non-zero value in this counter may indicate an opportunity to +** improvement performance by adding permanent indices that do not +** need to be reinitialized each time the statement is run.
+**
+*/ +#define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 +#define SQLITE_STMTSTATUS_SORT 2 +#define SQLITE_STMTSTATUS_AUTOINDEX 3 + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache type is opaque. It is implemented by +** the pluggable module. The SQLite core has no knowledge of +** its size or internal structure and never deals with the +** sqlite3_pcache object except by holding and passing pointers +** to the object. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache sqlite3_pcache; + +/* +** CAPI3REF: Custom Page Cache Object +** +** The sqlite3_pcache_page object represents a single page in the +** page cache. The page cache will allocate instances of this +** object. Various methods of the page cache use pointers to instances +** of this object as parameters or as their return value. +** +** See [sqlite3_pcache_methods2] for additional information. +*/ +typedef struct sqlite3_pcache_page sqlite3_pcache_page; +struct sqlite3_pcache_page { + void *pBuf; /* The content of the page */ + void *pExtra; /* Extra information associated with the page */ +}; + +/* +** CAPI3REF: Application Defined Page Cache. +** KEYWORDS: {page cache} +** +** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +** register an alternative page cache implementation by passing in an +** instance of the sqlite3_pcache_methods2 structure.)^ +** In many applications, most of the heap memory allocated by +** SQLite is used for the page cache. +** By implementing a +** custom page cache using this API, an application can better control +** the amount of memory consumed by SQLite, the way in which +** that memory is allocated and released, and the policies used to +** determine exactly which parts of a database file are cached and for +** how long. +** +** The alternative page cache mechanism is an +** extreme measure that is only needed by the most demanding applications. +** The built-in page cache is recommended for most uses. +** +** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +** internal buffer by SQLite within the call to [sqlite3_config]. Hence +** the application may discard the parameter after the call to +** [sqlite3_config()] returns.)^ +** +** [[the xInit() page cache method]] +** ^(The xInit() method is called once for each effective +** call to [sqlite3_initialize()])^ +** (usually only once during the lifetime of the process). ^(The xInit() +** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +** The intent of the xInit() method is to set up global data structures +** required by the custom page cache implementation. +** ^(If the xInit() method is NULL, then the +** built-in default page cache is used instead of the application defined +** page cache.)^ +** +** [[the xShutdown() page cache method]] +** ^The xShutdown() method is called by [sqlite3_shutdown()]. +** It can be used to clean up +** any outstanding resources before process shutdown, if required. +** ^The xShutdown() method may be NULL. +** +** ^SQLite automatically serializes calls to the xInit method, +** so the xInit method need not be threadsafe. ^The +** xShutdown method is only called from [sqlite3_shutdown()] so it does +** not need to be threadsafe either. All other methods must be threadsafe +** in multithreaded applications. +** +** ^SQLite will never invoke xInit() more than once without an intervening +** call to xShutdown(). +** +** [[the xCreate() page cache methods]] +** ^SQLite invokes the xCreate() method to construct a new cache instance. +** SQLite will typically create one cache instance for each open database file, +** though this is not guaranteed. ^The +** first parameter, szPage, is the size in bytes of the pages that must +** be allocated by the cache. ^szPage will always a power of two. ^The +** second parameter szExtra is a number of bytes of extra storage +** associated with each page cache entry. ^The szExtra parameter will +** a number less than 250. SQLite will use the +** extra szExtra bytes on each page to store metadata about the underlying +** database page on disk. The value passed into szExtra depends +** on the SQLite version, the target platform, and how SQLite was compiled. +** ^The third argument to xCreate(), bPurgeable, is true if the cache being +** created will be used to cache database pages of a file stored on disk, or +** false if it is used for an in-memory database. The cache implementation +** does not have to do anything special based with the value of bPurgeable; +** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +** never invoke xUnpin() except to deliberately delete a page. +** ^In other words, calls to xUnpin() on a cache with bPurgeable set to +** false will always have the "discard" flag set to true. +** ^Hence, a cache created with bPurgeable false will +** never contain any unpinned pages. +** +** [[the xCachesize() page cache method]] +** ^(The xCachesize() method may be called at any time by SQLite to set the +** suggested maximum cache-size (number of pages stored by) the cache +** instance passed as the first argument. This is the value configured using +** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +** parameter, the implementation is not required to do anything with this +** value; it is advisory only. +** +** [[the xPagecount() page cache methods]] +** The xPagecount() method must return the number of pages currently +** stored in the cache, both pinned and unpinned. +** +** [[the xFetch() page cache methods]] +** The xFetch() method locates a page in the cache and returns a pointer to +** an sqlite3_pcache_page object associated with that page, or a NULL pointer. +** The pBuf element of the returned sqlite3_pcache_page object will be a +** pointer to a buffer of szPage bytes used to store the content of a +** single database page. The pExtra element of sqlite3_pcache_page will be +** a pointer to the szExtra bytes of extra storage that SQLite has requested +** for each entry in the page cache. +** +** The page to be fetched is determined by the key. ^The minimum key value +** is 1. After it has been retrieved using xFetch, the page is considered +** to be "pinned". +** +** If the requested page is already in the page cache, then the page cache +** implementation must return a pointer to the page buffer with its content +** intact. If the requested page is not already in the cache, then the +** cache implementation should use the value of the createFlag +** parameter to help it determined what action to take: +** +** +**
createFlag Behavior when page is not already in cache +**
0 Do not allocate a new page. Return NULL. +**
1 Allocate a new page if it easy and convenient to do so. +** Otherwise return NULL. +**
2 Make every effort to allocate a new page. Only return +** NULL if allocating a new page is effectively impossible. +**
+** +** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +** will only use a createFlag of 2 after a prior call with a createFlag of 1 +** failed.)^ In between the to xFetch() calls, SQLite may +** attempt to unpin one or more cache pages by spilling the content of +** pinned pages to disk and synching the operating system disk cache. +** +** [[the xUnpin() page cache method]] +** ^xUnpin() is called by SQLite with a pointer to a currently pinned page +** as its second argument. If the third parameter, discard, is non-zero, +** then the page must be evicted from the cache. +** ^If the discard parameter is +** zero, then the page may be discarded or retained at the discretion of +** page cache implementation. ^The page cache implementation +** may choose to evict unpinned pages at any time. +** +** The cache must not perform any reference counting. A single +** call to xUnpin() unpins the page regardless of the number of prior calls +** to xFetch(). +** +** [[the xRekey() page cache methods]] +** The xRekey() method is used to change the key value associated with the +** page passed as the second argument. If the cache +** previously contains an entry associated with newKey, it must be +** discarded. ^Any prior cache entry associated with newKey is guaranteed not +** to be pinned. +** +** When SQLite calls the xTruncate() method, the cache must discard all +** existing cache entries with page numbers (keys) greater than or equal +** to the value of the iLimit parameter passed to xTruncate(). If any +** of these pages are pinned, they are implicitly unpinned, meaning that +** they can be safely discarded. +** +** [[the xDestroy() page cache method]] +** ^The xDestroy() method is used to delete a cache allocated by xCreate(). +** All resources associated with the specified cache should be freed. ^After +** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +** handle invalid, and will not use it with any other sqlite3_pcache_methods2 +** functions. +** +** [[the xShrink() page cache method]] +** ^SQLite invokes the xShrink() method when it wants the page cache to +** free up as much of heap memory as possible. The page cache implementation +** is not obligated to free any memory, but well-behaved implementations should +** do their best. +*/ +typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2; +struct sqlite3_pcache_methods2 { + int iVersion; + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard); + void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*, + unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); + void (*xShrink)(sqlite3_pcache*); +}; + +/* +** This is the obsolete pcache_methods object that has now been replaced +** by sqlite3_pcache_methods2. This object is not used by SQLite. It is +** retained in the header file for backwards compatibility only. +*/ +typedef struct sqlite3_pcache_methods sqlite3_pcache_methods; +struct sqlite3_pcache_methods { + void *pArg; + int (*xInit)(void*); + void (*xShutdown)(void*); + sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable); + void (*xCachesize)(sqlite3_pcache*, int nCachesize); + int (*xPagecount)(sqlite3_pcache*); + void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); + void (*xUnpin)(sqlite3_pcache*, void*, int discard); + void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); + void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); + void (*xDestroy)(sqlite3_pcache*); +}; + + +/* +** CAPI3REF: Online Backup Object +** +** The sqlite3_backup object records state information about an ongoing +** online backup operation. ^The sqlite3_backup object is created by +** a call to [sqlite3_backup_init()] and is destroyed by a call to +** [sqlite3_backup_finish()]. +** +** See Also: [Using the SQLite Online Backup API] +*/ +typedef struct sqlite3_backup sqlite3_backup; + +/* +** CAPI3REF: Online Backup API. +** +** The backup API copies the content of one database into another. +** It is useful either for creating backups of databases or +** for copying in-memory databases to or from persistent files. +** +** See Also: [Using the SQLite Online Backup API] +** +** ^SQLite holds a write transaction open on the destination database file +** for the duration of the backup operation. +** ^The source database is read-locked only while it is being read; +** it is not locked continuously for the entire backup operation. +** ^Thus, the backup may be performed on a live source database without +** preventing other database connections from +** reading or writing to the source database while the backup is underway. +** +** ^(To perform a backup operation: +**
    +**
  1. sqlite3_backup_init() is called once to initialize the +** backup, +**
  2. sqlite3_backup_step() is called one or more times to transfer +** the data between the two databases, and finally +**
  3. sqlite3_backup_finish() is called to release all resources +** associated with the backup operation. +**
)^ +** There should be exactly one call to sqlite3_backup_finish() for each +** successful call to sqlite3_backup_init(). +** +** [[sqlite3_backup_init()]] sqlite3_backup_init() +** +** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the +** [database connection] associated with the destination database +** and the database name, respectively. +** ^The database name is "main" for the main database, "temp" for the +** temporary database, or the name specified after the AS keyword in +** an [ATTACH] statement for an attached database. +** ^The S and M arguments passed to +** sqlite3_backup_init(D,N,S,M) identify the [database connection] +** and database name of the source database, respectively. +** ^The source and destination [database connections] (parameters S and D) +** must be different or else sqlite3_backup_init(D,N,S,M) will fail with +** an error. +** +** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is +** returned and an error code and error message are stored in the +** destination [database connection] D. +** ^The error code and message for the failed call to sqlite3_backup_init() +** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or +** [sqlite3_errmsg16()] functions. +** ^A successful call to sqlite3_backup_init() returns a pointer to an +** [sqlite3_backup] object. +** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and +** sqlite3_backup_finish() functions to perform the specified backup +** operation. +** +** [[sqlite3_backup_step()]] sqlite3_backup_step() +** +** ^Function sqlite3_backup_step(B,N) will copy up to N pages between +** the source and destination databases specified by [sqlite3_backup] object B. +** ^If N is negative, all remaining source pages are copied. +** ^If sqlite3_backup_step(B,N) successfully copies N pages and there +** are still more pages to be copied, then the function returns [SQLITE_OK]. +** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages +** from source to destination, then it returns [SQLITE_DONE]. +** ^If an error occurs while running sqlite3_backup_step(B,N), +** then an [error code] is returned. ^As well as [SQLITE_OK] and +** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY], +** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code. +** +** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if +**
    +**
  1. the destination database was opened read-only, or +**
  2. the destination database is using write-ahead-log journaling +** and the destination and source page sizes differ, or +**
  3. the destination database is an in-memory database and the +** destination and source page sizes differ. +**
)^ +** +** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then +** the [sqlite3_busy_handler | busy-handler function] +** is invoked (if one is specified). ^If the +** busy-handler returns non-zero before the lock is available, then +** [SQLITE_BUSY] is returned to the caller. ^In this case the call to +** sqlite3_backup_step() can be retried later. ^If the source +** [database connection] +** is being used to write to the source database when sqlite3_backup_step() +** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this +** case the call to sqlite3_backup_step() can be retried later on. ^(If +** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or +** [SQLITE_READONLY] is returned, then +** there is no point in retrying the call to sqlite3_backup_step(). These +** errors are considered fatal.)^ The application must accept +** that the backup operation has failed and pass the backup operation handle +** to the sqlite3_backup_finish() to release associated resources. +** +** ^The first call to sqlite3_backup_step() obtains an exclusive lock +** on the destination file. ^The exclusive lock is not released until either +** sqlite3_backup_finish() is called or the backup operation is complete +** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to +** sqlite3_backup_step() obtains a [shared lock] on the source database that +** lasts for the duration of the sqlite3_backup_step() call. +** ^Because the source database is not locked between calls to +** sqlite3_backup_step(), the source database may be modified mid-way +** through the backup process. ^If the source database is modified by an +** external process or via a database connection other than the one being +** used by the backup operation, then the backup will be automatically +** restarted by the next call to sqlite3_backup_step(). ^If the source +** database is modified by the using the same database connection as is used +** by the backup operation, then the backup database is automatically +** updated at the same time. +** +** [[sqlite3_backup_finish()]] sqlite3_backup_finish() +** +** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the +** application wishes to abandon the backup operation, the application +** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish(). +** ^The sqlite3_backup_finish() interfaces releases all +** resources associated with the [sqlite3_backup] object. +** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any +** active write-transaction on the destination database is rolled back. +** The [sqlite3_backup] object is invalid +** and may not be used following a call to sqlite3_backup_finish(). +** +** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no +** sqlite3_backup_step() errors occurred, regardless or whether or not +** sqlite3_backup_step() completed. +** ^If an out-of-memory condition or IO error occurred during any prior +** sqlite3_backup_step() call on the same [sqlite3_backup] object, then +** sqlite3_backup_finish() returns the corresponding [error code]. +** +** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step() +** is not a permanent error and does not affect the return value of +** sqlite3_backup_finish(). +** +** [[sqlite3_backup__remaining()]] [[sqlite3_backup_pagecount()]] +** sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** +** ^Each call to sqlite3_backup_step() sets two values inside +** the [sqlite3_backup] object: the number of pages still to be backed +** up and the total number of pages in the source database file. +** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces +** retrieve these two values, respectively. +** +** ^The values returned by these functions are only updated by +** sqlite3_backup_step(). ^If the source database is modified during a backup +** operation, then the values are not updated to account for any extra +** pages that need to be updated or the size of the source database file +** changing. +** +** Concurrent Usage of Database Handles +** +** ^The source [database connection] may be used by the application for other +** purposes while a backup operation is underway or being initialized. +** ^If SQLite is compiled and configured to support threadsafe database +** connections, then the source database connection may be used concurrently +** from within other threads. +** +** However, the application must guarantee that the destination +** [database connection] is not passed to any other API (by any thread) after +** sqlite3_backup_init() is called and before the corresponding call to +** sqlite3_backup_finish(). SQLite does not currently check to see +** if the application incorrectly accesses the destination [database connection] +** and so no error code is reported, but the operations may malfunction +** nevertheless. Use of the destination database connection while a +** backup is in progress might also also cause a mutex deadlock. +** +** If running in [shared cache mode], the application must +** guarantee that the shared cache used by the destination database +** is not accessed while the backup is running. In practice this means +** that the application must guarantee that the disk file being +** backed up to is not accessed by any connection within the process, +** not just the specific connection that was passed to sqlite3_backup_init(). +** +** The [sqlite3_backup] object itself is partially threadsafe. Multiple +** threads may safely make multiple concurrent calls to sqlite3_backup_step(). +** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() +** APIs are not strictly speaking threadsafe. If they are invoked at the +** same time as another thread is invoking sqlite3_backup_step() it is +** possible that they return invalid values. +*/ +SQLITE_API sqlite3_backup *sqlite3_backup_init( + sqlite3 *pDest, /* Destination database handle */ + const char *zDestName, /* Destination database name */ + sqlite3 *pSource, /* Source database handle */ + const char *zSourceName /* Source database name */ +); +SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage); +SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p); +SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p); + +/* +** CAPI3REF: Unlock Notification +** +** ^When running in shared-cache mode, a database operation may fail with +** an [SQLITE_LOCKED] error if the required locks on the shared-cache or +** individual tables within the shared-cache cannot be obtained. See +** [SQLite Shared-Cache Mode] for a description of shared-cache locking. +** ^This API may be used to register a callback that SQLite will invoke +** when the connection currently holding the required lock relinquishes it. +** ^This API is only available if the library was compiled with the +** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined. +** +** See Also: [Using the SQLite Unlock Notification Feature]. +** +** ^Shared-cache locks are released when a database connection concludes +** its current transaction, either by committing it or rolling it back. +** +** ^When a connection (known as the blocked connection) fails to obtain a +** shared-cache lock and SQLITE_LOCKED is returned to the caller, the +** identity of the database connection (the blocking connection) that +** has locked the required resource is stored internally. ^After an +** application receives an SQLITE_LOCKED error, it may call the +** sqlite3_unlock_notify() method with the blocked connection handle as +** the first argument to register for a callback that will be invoked +** when the blocking connections current transaction is concluded. ^The +** callback is invoked from within the [sqlite3_step] or [sqlite3_close] +** call that concludes the blocking connections transaction. +** +** ^(If sqlite3_unlock_notify() is called in a multi-threaded application, +** there is a chance that the blocking connection will have already +** concluded its transaction by the time sqlite3_unlock_notify() is invoked. +** If this happens, then the specified callback is invoked immediately, +** from within the call to sqlite3_unlock_notify().)^ +** +** ^If the blocked connection is attempting to obtain a write-lock on a +** shared-cache table, and more than one other connection currently holds +** a read-lock on the same table, then SQLite arbitrarily selects one of +** the other connections to use as the blocking connection. +** +** ^(There may be at most one unlock-notify callback registered by a +** blocked connection. If sqlite3_unlock_notify() is called when the +** blocked connection already has a registered unlock-notify callback, +** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is +** called with a NULL pointer as its second argument, then any existing +** unlock-notify callback is canceled. ^The blocked connections +** unlock-notify callback may also be canceled by closing the blocked +** connection using [sqlite3_close()]. +** +** The unlock-notify callback is not reentrant. If an application invokes +** any sqlite3_xxx API functions from within an unlock-notify callback, a +** crash or deadlock may be the result. +** +** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always +** returns SQLITE_OK. +** +** Callback Invocation Details +** +** When an unlock-notify callback is registered, the application provides a +** single void* pointer that is passed to the callback when it is invoked. +** However, the signature of the callback function allows SQLite to pass +** it an array of void* context pointers. The first argument passed to +** an unlock-notify callback is a pointer to an array of void* pointers, +** and the second is the number of entries in the array. +** +** When a blocking connections transaction is concluded, there may be +** more than one blocked connection that has registered for an unlock-notify +** callback. ^If two or more such blocked connections have specified the +** same callback function, then instead of invoking the callback function +** multiple times, it is invoked once with the set of void* context pointers +** specified by the blocked connections bundled together into an array. +** This gives the application an opportunity to prioritize any actions +** related to the set of unblocked database connections. +** +** Deadlock Detection +** +** Assuming that after registering for an unlock-notify callback a +** database waits for the callback to be issued before taking any further +** action (a reasonable assumption), then using this API may cause the +** application to deadlock. For example, if connection X is waiting for +** connection Y's transaction to be concluded, and similarly connection +** Y is waiting on connection X's transaction, then neither connection +** will proceed and the system may remain deadlocked indefinitely. +** +** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock +** detection. ^If a given call to sqlite3_unlock_notify() would put the +** system in a deadlocked state, then SQLITE_LOCKED is returned and no +** unlock-notify callback is registered. The system is said to be in +** a deadlocked state if connection A has registered for an unlock-notify +** callback on the conclusion of connection B's transaction, and connection +** B has itself registered for an unlock-notify callback when connection +** A's transaction is concluded. ^Indirect deadlock is also detected, so +** the system is also considered to be deadlocked if connection B has +** registered for an unlock-notify callback on the conclusion of connection +** C's transaction, where connection C is waiting on connection A. ^Any +** number of levels of indirection are allowed. +** +** The "DROP TABLE" Exception +** +** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost +** always appropriate to call sqlite3_unlock_notify(). There is however, +** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement, +** SQLite checks if there are any currently executing SELECT statements +** that belong to the same connection. If there are, SQLITE_LOCKED is +** returned. In this case there is no "blocking connection", so invoking +** sqlite3_unlock_notify() results in the unlock-notify callback being +** invoked immediately. If the application then re-attempts the "DROP TABLE" +** or "DROP INDEX" query, an infinite loop might be the result. +** +** One way around this problem is to check the extended error code returned +** by an sqlite3_step() call. ^(If there is a blocking connection, then the +** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in +** the special "DROP TABLE/INDEX" case, the extended error code is just +** SQLITE_LOCKED.)^ +*/ +SQLITE_API int sqlite3_unlock_notify( + sqlite3 *pBlocked, /* Waiting connection */ + void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */ + void *pNotifyArg /* Argument to pass to xNotify */ +); + + +/* +** CAPI3REF: String Comparison +** +** ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications +** and extensions to compare the contents of two buffers containing UTF-8 +** strings in a case-independent fashion, using the same definition of "case +** independence" that SQLite uses internally when comparing identifiers. +*/ +SQLITE_API int sqlite3_stricmp(const char *, const char *); +SQLITE_API int sqlite3_strnicmp(const char *, const char *, int); + +/* +** CAPI3REF: Error Logging Interface +** +** ^The [sqlite3_log()] interface writes a message into the error log +** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()]. +** ^If logging is enabled, the zFormat string and subsequent arguments are +** used with [sqlite3_snprintf()] to generate the final output string. +** +** The sqlite3_log() interface is intended for use by extensions such as +** virtual tables, collating functions, and SQL functions. While there is +** nothing to prevent an application from calling sqlite3_log(), doing so +** is considered bad form. +** +** The zFormat string must not be NULL. +** +** To avoid deadlocks and other threading problems, the sqlite3_log() routine +** will not use dynamically allocated memory. The log message is stored in +** a fixed-length buffer on the stack. If the log message is longer than +** a few hundred characters, it will be truncated to the length of the +** buffer. +*/ +SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...); + +/* +** CAPI3REF: Write-Ahead Log Commit Hook +** +** ^The [sqlite3_wal_hook()] function is used to register a callback that +** will be invoked each time a database connection commits data to a +** [write-ahead log] (i.e. whenever a transaction is committed in +** [journal_mode | journal_mode=WAL mode]). +** +** ^The callback is invoked by SQLite after the commit has taken place and +** the associated write-lock on the database released, so the implementation +** may read, write or [checkpoint] the database as required. +** +** ^The first parameter passed to the callback function when it is invoked +** is a copy of the third parameter passed to sqlite3_wal_hook() when +** registering the callback. ^The second is a copy of the database handle. +** ^The third parameter is the name of the database that was written to - +** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter +** is the number of pages currently in the write-ahead log file, +** including those that were just committed. +** +** The callback function should normally return [SQLITE_OK]. ^If an error +** code is returned, that error will propagate back up through the +** SQLite code base to cause the statement that provoked the callback +** to report an error, though the commit will have still occurred. If the +** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value +** that does not correspond to any valid SQLite error code, the results +** are undefined. +** +** A single database handle may have at most a single write-ahead log callback +** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any +** previously registered write-ahead log callback. ^Note that the +** [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will +** those overwrite any prior [sqlite3_wal_hook()] settings. +*/ +SQLITE_API void *sqlite3_wal_hook( + sqlite3*, + int(*)(void *,sqlite3*,const char*,int), + void* +); + +/* +** CAPI3REF: Configure an auto-checkpoint +** +** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around +** [sqlite3_wal_hook()] that causes any database on [database connection] D +** to automatically [checkpoint] +** after committing a transaction if there are N or +** more frames in the [write-ahead log] file. ^Passing zero or +** a negative value as the nFrame parameter disables automatic +** checkpoints entirely. +** +** ^The callback registered by this function replaces any existing callback +** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback +** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism +** configured by this function. +** +** ^The [wal_autocheckpoint pragma] can be used to invoke this interface +** from SQL. +** +** ^Every new [database connection] defaults to having the auto-checkpoint +** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT] +** pages. The use of this interface +** is only necessary if the default setting is found to be suboptimal +** for a particular application. +*/ +SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N); + +/* +** CAPI3REF: Checkpoint a database +** +** ^The [sqlite3_wal_checkpoint(D,X)] interface causes database named X +** on [database connection] D to be [checkpointed]. ^If X is NULL or an +** empty string, then a checkpoint is run on all databases of +** connection D. ^If the database connection D is not in +** [WAL | write-ahead log mode] then this interface is a harmless no-op. +** +** ^The [wal_checkpoint pragma] can be used to invoke this interface +** from SQL. ^The [sqlite3_wal_autocheckpoint()] interface and the +** [wal_autocheckpoint pragma] can be used to cause this interface to be +** run whenever the WAL reaches a certain size threshold. +** +** See also: [sqlite3_wal_checkpoint_v2()] +*/ +SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb); + +/* +** CAPI3REF: Checkpoint a database +** +** Run a checkpoint operation on WAL database zDb attached to database +** handle db. The specific operation is determined by the value of the +** eMode parameter: +** +**
+**
SQLITE_CHECKPOINT_PASSIVE
+** Checkpoint as many frames as possible without waiting for any database +** readers or writers to finish. Sync the db file if all frames in the log +** are checkpointed. This mode is the same as calling +** sqlite3_wal_checkpoint(). The busy-handler callback is never invoked. +** +**
SQLITE_CHECKPOINT_FULL
+** This mode blocks (calls the busy-handler callback) until there is no +** database writer and all readers are reading from the most recent database +** snapshot. It then checkpoints all frames in the log file and syncs the +** database file. This call blocks database writers while it is running, +** but not database readers. +** +**
SQLITE_CHECKPOINT_RESTART
+** This mode works the same way as SQLITE_CHECKPOINT_FULL, except after +** checkpointing the log file it blocks (calls the busy-handler callback) +** until all readers are reading from the database file only. This ensures +** that the next client to write to the database file restarts the log file +** from the beginning. This call blocks database writers while it is running, +** but not database readers. +**
+** +** If pnLog is not NULL, then *pnLog is set to the total number of frames in +** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to +** the total number of checkpointed frames (including any that were already +** checkpointed when this function is called). *pnLog and *pnCkpt may be +** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK. +** If no values are available because of an error, they are both set to -1 +** before returning to communicate this to the caller. +** +** All calls obtain an exclusive "checkpoint" lock on the database file. If +** any other process is running a checkpoint operation at the same time, the +** lock cannot be obtained and SQLITE_BUSY is returned. Even if there is a +** busy-handler configured, it will not be invoked in this case. +** +** The SQLITE_CHECKPOINT_FULL and RESTART modes also obtain the exclusive +** "writer" lock on the database file. If the writer lock cannot be obtained +** immediately, and a busy-handler is configured, it is invoked and the writer +** lock retried until either the busy-handler returns 0 or the lock is +** successfully obtained. The busy-handler is also invoked while waiting for +** database readers as described above. If the busy-handler returns 0 before +** the writer lock is obtained or while waiting for database readers, the +** checkpoint operation proceeds from that point in the same way as +** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible +** without blocking any further. SQLITE_BUSY is returned in this case. +** +** If parameter zDb is NULL or points to a zero length string, then the +** specified operation is attempted on all WAL databases. In this case the +** values written to output parameters *pnLog and *pnCkpt are undefined. If +** an SQLITE_BUSY error is encountered when processing one or more of the +** attached WAL databases, the operation is still attempted on any remaining +** attached databases and SQLITE_BUSY is returned to the caller. If any other +** error occurs while processing an attached database, processing is abandoned +** and the error code returned to the caller immediately. If no error +** (SQLITE_BUSY or otherwise) is encountered while processing the attached +** databases, SQLITE_OK is returned. +** +** If database zDb is the name of an attached database that is not in WAL +** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If +** zDb is not NULL (or a zero length string) and is not the name of any +** attached database, SQLITE_ERROR is returned to the caller. +*/ +SQLITE_API int sqlite3_wal_checkpoint_v2( + sqlite3 *db, /* Database handle */ + const char *zDb, /* Name of attached database (or NULL) */ + int eMode, /* SQLITE_CHECKPOINT_* value */ + int *pnLog, /* OUT: Size of WAL log in frames */ + int *pnCkpt /* OUT: Total number of frames checkpointed */ +); + +/* +** CAPI3REF: Checkpoint operation parameters +** +** These constants can be used as the 3rd parameter to +** [sqlite3_wal_checkpoint_v2()]. See the [sqlite3_wal_checkpoint_v2()] +** documentation for additional information about the meaning and use of +** each of these values. +*/ +#define SQLITE_CHECKPOINT_PASSIVE 0 +#define SQLITE_CHECKPOINT_FULL 1 +#define SQLITE_CHECKPOINT_RESTART 2 + +/* +** CAPI3REF: Virtual Table Interface Configuration +** +** This function may be called by either the [xConnect] or [xCreate] method +** of a [virtual table] implementation to configure +** various facets of the virtual table interface. +** +** If this interface is invoked outside the context of an xConnect or +** xCreate virtual table method then the behavior is undefined. +** +** At present, there is only one option that may be configured using +** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].) Further options +** may be added in the future. +*/ +SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...); + +/* +** CAPI3REF: Virtual Table Configuration Options +** +** These macros define the various options to the +** [sqlite3_vtab_config()] interface that [virtual table] implementations +** can use to customize and optimize their behavior. +** +**
+**
SQLITE_VTAB_CONSTRAINT_SUPPORT +**
Calls of the form +** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported, +** where X is an integer. If X is zero, then the [virtual table] whose +** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not +** support constraints. In this configuration (which is the default) if +** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire +** statement is rolled back as if [ON CONFLICT | OR ABORT] had been +** specified as part of the users SQL statement, regardless of the actual +** ON CONFLICT mode specified. +** +** If X is non-zero, then the virtual table implementation guarantees +** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before +** any modifications to internal or persistent data structures have been made. +** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite +** is able to roll back a statement or database transaction, and abandon +** or continue processing the current SQL statement as appropriate. +** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns +** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode +** had been ABORT. +** +** Virtual table implementations that are required to handle OR REPLACE +** must do so within the [xUpdate] method. If a call to the +** [sqlite3_vtab_on_conflict()] function indicates that the current ON +** CONFLICT policy is REPLACE, the virtual table implementation should +** silently replace the appropriate rows within the xUpdate callback and +** return SQLITE_OK. Or, if this is not possible, it may return +** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT +** constraint handling. +**
+*/ +#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1 + +/* +** CAPI3REF: Determine The Virtual Table Conflict Policy +** +** This function may only be called from within a call to the [xUpdate] method +** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The +** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL], +** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode +** of the SQL statement that triggered the call to the [xUpdate] method of the +** [virtual table]. +*/ +SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *); + +/* +** CAPI3REF: Conflict resolution modes +** +** These constants are returned by [sqlite3_vtab_on_conflict()] to +** inform a [virtual table] implementation what the [ON CONFLICT] mode +** is for the SQL statement being evaluated. +** +** Note that the [SQLITE_IGNORE] constant is also used as a potential +** return value from the [sqlite3_set_authorizer()] callback and that +** [SQLITE_ABORT] is also a [result code]. +*/ +#define SQLITE_ROLLBACK 1 +/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */ +#define SQLITE_FAIL 3 +/* #define SQLITE_ABORT 4 // Also an error code */ +#define SQLITE_REPLACE 5 + + + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#if 0 +} /* End of the 'extern "C"' block */ +#endif +#endif + +/* +** 2010 August 30 +** +** 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. +** +************************************************************************* +*/ + +#ifndef _SQLITE3RTREE_H_ +#define _SQLITE3RTREE_H_ + + +#if 0 +extern "C" { +#endif + +typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry; + +/* +** Register a geometry callback named zGeom that can be used as part of an +** R-Tree geometry query as follows: +** +** SELECT ... FROM WHERE MATCH $zGeom(... params ...) +*/ +SQLITE_API int sqlite3_rtree_geometry_callback( + sqlite3 *db, + const char *zGeom, +#ifdef SQLITE_RTREE_INT_ONLY + int (*xGeom)(sqlite3_rtree_geometry*, int n, sqlite3_int64 *a, int *pRes), +#else + int (*xGeom)(sqlite3_rtree_geometry*, int n, double *a, int *pRes), +#endif + void *pContext +); + + +/* +** A pointer to a structure of the following type is passed as the first +** argument to callbacks registered using rtree_geometry_callback(). +*/ +struct sqlite3_rtree_geometry { + void *pContext; /* Copy of pContext passed to s_r_g_c() */ + int nParam; /* Size of array aParam[] */ + double *aParam; /* Parameters passed to SQL geom function */ + void *pUser; /* Callback implementation user data */ + void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */ +}; + + +#if 0 +} /* end of the 'extern "C"' block */ +#endif + +#endif /* ifndef _SQLITE3RTREE_H_ */ + + +/************** End of sqlite3.h *********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include hash.h in the middle of sqliteInt.h ******************/ +/************** Begin file hash.h ********************************************/ +/* +** 2001 September 22 +** +** 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 is the header file for the generic hash-table implementation +** used in SQLite. +*/ +#ifndef _SQLITE_HASH_H_ +#define _SQLITE_HASH_H_ + +/* Forward declarations of structures. */ +typedef struct Hash Hash; +typedef struct HashElem HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, some of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +** +** All elements of the hash table are on a single doubly-linked list. +** Hash.first points to the head of this list. +** +** There are Hash.htsize buckets. Each bucket points to a spot in +** the global doubly-linked list. The contents of the bucket are the +** element pointed to plus the next _ht.count-1 elements in the list. +** +** Hash.htsize and Hash.ht may be zero. In that case lookup is done +** by a linear search of the global list. For small tables, the +** Hash.ht table is never allocated because if there are few elements +** in the table, it is faster to do a linear search than to manage +** the hash table. +*/ +struct Hash { + unsigned int htsize; /* Number of buckets in the hash table */ + unsigned int count; /* Number of entries in this table */ + HashElem *first; /* The first element of the array */ + struct _ht { /* the hash table */ + int count; /* Number of entries with this hash */ + HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct HashElem { + HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + const char *pKey; int nKey; /* Key associated with this element */ +}; + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +SQLITE_PRIVATE void sqlite3HashInit(Hash*); +SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData); +SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey); +SQLITE_PRIVATE void sqlite3HashClear(Hash*); + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Hash h; +** HashElem *p; +** ... +** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ +** SomeStructure *pData = sqliteHashData(p); +** // do something with pData +** } +*/ +#define sqliteHashFirst(H) ((H)->first) +#define sqliteHashNext(E) ((E)->next) +#define sqliteHashData(E) ((E)->data) +/* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */ +/* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */ + +/* +** Number of entries in a hash table +*/ +/* #define sqliteHashCount(H) ((H)->count) // NOT USED */ + +#endif /* _SQLITE_HASH_H_ */ + +/************** End of hash.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include parse.h in the middle of sqliteInt.h *****************/ +/************** Begin file parse.h *******************************************/ +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_SAVEPOINT 13 +#define TK_RELEASE 14 +#define TK_TO 15 +#define TK_TABLE 16 +#define TK_CREATE 17 +#define TK_IF 18 +#define TK_NOT 19 +#define TK_EXISTS 20 +#define TK_TEMP 21 +#define TK_LP 22 +#define TK_RP 23 +#define TK_AS 24 +#define TK_COMMA 25 +#define TK_ID 26 +#define TK_INDEXED 27 +#define TK_ABORT 28 +#define TK_ACTION 29 +#define TK_AFTER 30 +#define TK_ANALYZE 31 +#define TK_ASC 32 +#define TK_ATTACH 33 +#define TK_BEFORE 34 +#define TK_BY 35 +#define TK_CASCADE 36 +#define TK_CAST 37 +#define TK_COLUMNKW 38 +#define TK_CONFLICT 39 +#define TK_DATABASE 40 +#define TK_DESC 41 +#define TK_DETACH 42 +#define TK_EACH 43 +#define TK_FAIL 44 +#define TK_FOR 45 +#define TK_IGNORE 46 +#define TK_INITIALLY 47 +#define TK_INSTEAD 48 +#define TK_LIKE_KW 49 +#define TK_MATCH 50 +#define TK_NO 51 +#define TK_KEY 52 +#define TK_OF 53 +#define TK_OFFSET 54 +#define TK_PRAGMA 55 +#define TK_RAISE 56 +#define TK_REPLACE 57 +#define TK_RESTRICT 58 +#define TK_ROW 59 +#define TK_TRIGGER 60 +#define TK_VACUUM 61 +#define TK_VIEW 62 +#define TK_VIRTUAL 63 +#define TK_REINDEX 64 +#define TK_RENAME 65 +#define TK_CTIME_KW 66 +#define TK_ANY 67 +#define TK_OR 68 +#define TK_AND 69 +#define TK_IS 70 +#define TK_BETWEEN 71 +#define TK_IN 72 +#define TK_ISNULL 73 +#define TK_NOTNULL 74 +#define TK_NE 75 +#define TK_EQ 76 +#define TK_GT 77 +#define TK_LE 78 +#define TK_LT 79 +#define TK_GE 80 +#define TK_ESCAPE 81 +#define TK_BITAND 82 +#define TK_BITOR 83 +#define TK_LSHIFT 84 +#define TK_RSHIFT 85 +#define TK_PLUS 86 +#define TK_MINUS 87 +#define TK_STAR 88 +#define TK_SLASH 89 +#define TK_REM 90 +#define TK_CONCAT 91 +#define TK_COLLATE 92 +#define TK_BITNOT 93 +#define TK_STRING 94 +#define TK_JOIN_KW 95 +#define TK_CONSTRAINT 96 +#define TK_DEFAULT 97 +#define TK_NULL 98 +#define TK_PRIMARY 99 +#define TK_UNIQUE 100 +#define TK_CHECK 101 +#define TK_REFERENCES 102 +#define TK_AUTOINCR 103 +#define TK_ON 104 +#define TK_INSERT 105 +#define TK_DELETE 106 +#define TK_UPDATE 107 +#define TK_SET 108 +#define TK_DEFERRABLE 109 +#define TK_FOREIGN 110 +#define TK_DROP 111 +#define TK_UNION 112 +#define TK_ALL 113 +#define TK_EXCEPT 114 +#define TK_INTERSECT 115 +#define TK_SELECT 116 +#define TK_DISTINCT 117 +#define TK_DOT 118 +#define TK_FROM 119 +#define TK_JOIN 120 +#define TK_USING 121 +#define TK_ORDER 122 +#define TK_GROUP 123 +#define TK_HAVING 124 +#define TK_LIMIT 125 +#define TK_WHERE 126 +#define TK_INTO 127 +#define TK_VALUES 128 +#define TK_INTEGER 129 +#define TK_FLOAT 130 +#define TK_BLOB 131 +#define TK_REGISTER 132 +#define TK_VARIABLE 133 +#define TK_CASE 134 +#define TK_WHEN 135 +#define TK_THEN 136 +#define TK_ELSE 137 +#define TK_INDEX 138 +#define TK_ALTER 139 +#define TK_ADD 140 +#define TK_TO_TEXT 141 +#define TK_TO_BLOB 142 +#define TK_TO_NUMERIC 143 +#define TK_TO_INT 144 +#define TK_TO_REAL 145 +#define TK_ISNOT 146 +#define TK_END_OF_FILE 147 +#define TK_ILLEGAL 148 +#define TK_SPACE 149 +#define TK_UNCLOSED_STRING 150 +#define TK_FUNCTION 151 +#define TK_COLUMN 152 +#define TK_AGG_FUNCTION 153 +#define TK_AGG_COLUMN 154 +#define TK_CONST_FUNC 155 +#define TK_UMINUS 156 +#define TK_UPLUS 157 + +/************** End of parse.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +#include +#include +#include +#include +#include + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +# define float sqlite_int64 +# define LONGDOUBLE_TYPE sqlite_int64 +# ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) +# endif +# define SQLITE_OMIT_DATETIME_FUNCS 1 +# define SQLITE_OMIT_TRACE 1 +# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +# undef SQLITE_HAVE_ISNAN +#endif +#ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (1e99) +#endif + +/* +** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 +** afterward. Having this macro allows us to cause the C compiler +** to omit code used by TEMP tables without messy #ifndef statements. +*/ +#ifdef SQLITE_OMIT_TEMPDB +#define OMIT_TEMPDB 1 +#else +#define OMIT_TEMPDB 0 +#endif + +/* +** The "file format" number is an integer that is incremented whenever +** the VDBE-level file format changes. The following macros define the +** the default file format for new databases and the maximum file format +** that the library can read. +*/ +#define SQLITE_MAX_FILE_FORMAT 4 +#ifndef SQLITE_DEFAULT_FILE_FORMAT +# define SQLITE_DEFAULT_FILE_FORMAT 4 +#endif + +/* +** Determine whether triggers are recursive by default. This can be +** changed at run-time using a pragma. +*/ +#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS +# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 +#endif + +/* +** Provide a default value for SQLITE_TEMP_STORE in case it is not specified +** on the command-line +*/ +#ifndef SQLITE_TEMP_STORE +# define SQLITE_TEMP_STORE 1 +#endif + +/* +** GCC does not define the offsetof() macro so we'll have to do it +** ourselves. +*/ +#ifndef offsetof +#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) +#endif + +/* +** Check to see if this machine uses EBCDIC. (Yes, believe it or +** not, there are still machines out there that use EBCDIC.) +*/ +#if 'A' == '\301' +# define SQLITE_EBCDIC 1 +#else +# define SQLITE_ASCII 1 +#endif + +/* +** Integers of known sizes. These typedefs might change for architectures +** where the sizes very. Preprocessor macros are available so that the +** types can be conveniently redefined at compile-type. Like this: +** +** cc '-DUINTPTR_TYPE=long long int' ... +*/ +#ifndef UINT32_TYPE +# ifdef HAVE_UINT32_T +# define UINT32_TYPE uint32_t +# else +# define UINT32_TYPE unsigned int +# endif +#endif +#ifndef UINT16_TYPE +# ifdef HAVE_UINT16_T +# define UINT16_TYPE uint16_t +# else +# define UINT16_TYPE unsigned short int +# endif +#endif +#ifndef INT16_TYPE +# ifdef HAVE_INT16_T +# define INT16_TYPE int16_t +# else +# define INT16_TYPE short int +# endif +#endif +#ifndef UINT8_TYPE +# ifdef HAVE_UINT8_T +# define UINT8_TYPE uint8_t +# else +# define UINT8_TYPE unsigned char +# endif +#endif +#ifndef INT8_TYPE +# ifdef HAVE_INT8_T +# define INT8_TYPE int8_t +# else +# define INT8_TYPE signed char +# endif +#endif +#ifndef LONGDOUBLE_TYPE +# define LONGDOUBLE_TYPE long double +#endif +typedef sqlite_int64 i64; /* 8-byte signed integer */ +typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ +typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ +typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ +typedef INT16_TYPE i16; /* 2-byte signed integer */ +typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ +typedef INT8_TYPE i8; /* 1-byte signed integer */ + +/* +** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value +** that can be stored in a u32 without loss of data. The value +** is 0x00000000ffffffff. But because of quirks of some compilers, we +** have to specify the value in the less intuitive manner shown: +*/ +#define SQLITE_MAX_U32 ((((u64)1)<<32)-1) + +/* +** The datatype used to store estimates of the number of rows in a +** table or index. This is an unsigned integer type. For 99.9% of +** the world, a 32-bit integer is sufficient. But a 64-bit integer +** can be used at compile-time if desired. +*/ +#ifdef SQLITE_64BIT_STATS + typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */ +#else + typedef u32 tRowcnt; /* 32-bit is the default */ +#endif + +/* +** Macros to determine whether the machine is big or little endian, +** evaluated at runtime. +*/ +#ifdef SQLITE_AMALGAMATION +SQLITE_PRIVATE const int sqlite3one = 1; +#else +SQLITE_PRIVATE const int sqlite3one; +#endif +#if defined(i386) || defined(__i386__) || defined(_M_IX86)\ + || defined(__x86_64) || defined(__x86_64__) +# define SQLITE_BIGENDIAN 0 +# define SQLITE_LITTLEENDIAN 1 +# define SQLITE_UTF16NATIVE SQLITE_UTF16LE +#else +# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) +# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) +# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) +#endif + +/* +** Constants for the largest and smallest possible 64-bit signed integers. +** These macros are designed to work correctly on both 32-bit and 64-bit +** compilers. +*/ +#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) +#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) + +/* +** Round up a number to the next larger multiple of 8. This is used +** to force 8-byte alignment on 64-bit architectures. +*/ +#define ROUND8(x) (((x)+7)&~7) + +/* +** Round down to the nearest multiple of 8 +*/ +#define ROUNDDOWN8(x) ((x)&~7) + +/* +** Assert that the pointer X is aligned to an 8-byte boundary. This +** macro is used only within assert() to verify that the code gets +** all alignment restrictions correct. +** +** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the +** underlying malloc() implemention might return us 4-byte aligned +** pointers. In that case, only verify 4-byte alignment. +*/ +#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC +# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0) +#else +# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0) +#endif + + +/* +** An instance of the following structure is used to store the busy-handler +** callback for a given sqlite handle. +** +** The sqlite.busyHandler member of the sqlite struct contains the busy +** callback for the database handle. Each pager opened via the sqlite +** handle is passed a pointer to sqlite.busyHandler. The busy-handler +** callback is currently invoked only from within pager.c. +*/ +typedef struct BusyHandler BusyHandler; +struct BusyHandler { + int (*xFunc)(void *,int); /* The busy callback */ + void *pArg; /* First arg to busy callback */ + int nBusy; /* Incremented with each busy call */ +}; + +/* +** Name of the master database table. The master database table +** is a special table that holds the names and attributes of all +** user tables and indices. +*/ +#define MASTER_NAME "sqlite_master" +#define TEMP_MASTER_NAME "sqlite_temp_master" + +/* +** The root-page of the master database table. +*/ +#define MASTER_ROOT 1 + +/* +** The name of the schema table. +*/ +#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) + +/* +** A convenience macro that returns the number of elements in +** an array. +*/ +#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) + +/* +** Determine if the argument is a power of two +*/ +#define IsPowerOfTwo(X) (((X)&((X)-1))==0) + +/* +** The following value as a destructor means to use sqlite3DbFree(). +** The sqlite3DbFree() routine requires two parameters instead of the +** one parameter that destructors normally want. So we have to introduce +** this magic value that the code knows to handle differently. Any +** pointer will work here as long as it is distinct from SQLITE_STATIC +** and SQLITE_TRANSIENT. +*/ +#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize) + +/* +** When SQLITE_OMIT_WSD is defined, it means that the target platform does +** not support Writable Static Data (WSD) such as global and static variables. +** All variables must either be on the stack or dynamically allocated from +** the heap. When WSD is unsupported, the variable declarations scattered +** throughout the SQLite code must become constants instead. The SQLITE_WSD +** macro is used for this purpose. And instead of referencing the variable +** directly, we use its constant as a key to lookup the run-time allocated +** buffer that holds real variable. The constant is also the initializer +** for the run-time allocated buffer. +** +** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL +** macros become no-ops and have zero performance impact. +*/ +#ifdef SQLITE_OMIT_WSD + #define SQLITE_WSD const + #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) + #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) +SQLITE_API int sqlite3_wsd_init(int N, int J); +SQLITE_API void *sqlite3_wsd_find(void *K, int L); +#else + #define SQLITE_WSD + #define GLOBAL(t,v) v + #define sqlite3GlobalConfig sqlite3Config +#endif + +/* +** The following macros are used to suppress compiler warnings and to +** make it clear to human readers when a function parameter is deliberately +** left unused within the body of a function. This usually happens when +** a function is called via a function pointer. For example the +** implementation of an SQL aggregate step callback may not use the +** parameter indicating the number of arguments passed to the aggregate, +** if it knows that this is enforced elsewhere. +** +** When a function parameter is not used at all within the body of a function, +** it is generally named "NotUsed" or "NotUsed2" to make things even clearer. +** However, these macros may also be used to suppress warnings related to +** parameters that may or may not be used depending on compilation options. +** For example those parameters only used in assert() statements. In these +** cases the parameters are named as per the usual conventions. +*/ +#define UNUSED_PARAMETER(x) (void)(x) +#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) + +/* +** Forward references to structures +*/ +typedef struct AggInfo AggInfo; +typedef struct AuthContext AuthContext; +typedef struct AutoincInfo AutoincInfo; +typedef struct Bitvec Bitvec; +typedef struct CollSeq CollSeq; +typedef struct Column Column; +typedef struct Db Db; +typedef struct Schema Schema; +typedef struct Expr Expr; +typedef struct ExprList ExprList; +typedef struct ExprSpan ExprSpan; +typedef struct FKey FKey; +typedef struct FuncDestructor FuncDestructor; +typedef struct FuncDef FuncDef; +typedef struct FuncDefHash FuncDefHash; +typedef struct IdList IdList; +typedef struct Index Index; +typedef struct IndexSample IndexSample; +typedef struct KeyClass KeyClass; +typedef struct KeyInfo KeyInfo; +typedef struct Lookaside Lookaside; +typedef struct LookasideSlot LookasideSlot; +typedef struct Module Module; +typedef struct NameContext NameContext; +typedef struct Parse Parse; +typedef struct RowSet RowSet; +typedef struct Savepoint Savepoint; +typedef struct Select Select; +typedef struct SelectDest SelectDest; +typedef struct SrcList SrcList; +typedef struct StrAccum StrAccum; +typedef struct Table Table; +typedef struct TableLock TableLock; +typedef struct Token Token; +typedef struct Trigger Trigger; +typedef struct TriggerPrg TriggerPrg; +typedef struct TriggerStep TriggerStep; +typedef struct UnpackedRecord UnpackedRecord; +typedef struct VTable VTable; +typedef struct VtabCtx VtabCtx; +typedef struct Walker Walker; +typedef struct WherePlan WherePlan; +typedef struct WhereInfo WhereInfo; +typedef struct WhereLevel WhereLevel; + +/* +** Defer sourcing vdbe.h and btree.h until after the "u8" and +** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque +** pointer types (i.e. FuncDef) defined above. +*/ +/************** Include btree.h in the middle of sqliteInt.h *****************/ +/************** Begin file btree.h *******************************************/ +/* +** 2001 September 15 +** +** 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 header file defines the interface that the sqlite B-Tree file +** subsystem. See comments in the source code for a detailed description +** of what each interface routine does. +*/ +#ifndef _BTREE_H_ +#define _BTREE_H_ + +/* TODO: This definition is just included so other modules compile. It +** needs to be revisited. +*/ +#define SQLITE_N_BTREE_META 10 + +/* +** If defined as non-zero, auto-vacuum is enabled by default. Otherwise +** it must be turned on for each database using "PRAGMA auto_vacuum = 1". +*/ +#ifndef SQLITE_DEFAULT_AUTOVACUUM + #define SQLITE_DEFAULT_AUTOVACUUM 0 +#endif + +#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ +#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ +#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ + +/* +** Forward declarations of structure +*/ +typedef struct Btree Btree; +typedef struct BtCursor BtCursor; +typedef struct BtShared BtShared; + + +SQLITE_PRIVATE int sqlite3BtreeOpen( + sqlite3_vfs *pVfs, /* VFS to use with this b-tree */ + const char *zFilename, /* Name of database file to open */ + sqlite3 *db, /* Associated database connection */ + Btree **ppBtree, /* Return open Btree* here */ + int flags, /* Flags */ + int vfsFlags /* Flags passed through to VFS open */ +); + +/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the +** following values. +** +** NOTE: These values must match the corresponding PAGER_ values in +** pager.h. +*/ +#define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */ +#define BTREE_MEMORY 2 /* This is an in-memory DB */ +#define BTREE_SINGLE 4 /* The file contains at most 1 b-tree */ +#define BTREE_UNORDERED 8 /* Use of a hash implementation is OK */ + +SQLITE_PRIVATE int sqlite3BtreeClose(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeSetSafetyLevel(Btree*,int,int,int); +SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix); +SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*); +SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int); +SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*); +SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree*); +#if defined(SQLITE_HAS_CODEC) || defined(SQLITE_DEBUG) +SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p); +#endif +SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int); +SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *); +SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); +SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int); +SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*); +SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int); +SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags); +SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree*); +SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree*); +SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*); +SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); +SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree); +SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock); +SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int); + +SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *); +SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *); +SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *); + +SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *); + +/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR +** of the flags shown below. +** +** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set. +** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data +** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With +** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored +** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL +** indices.) +*/ +#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ +#define BTREE_BLOBKEY 2 /* Table has keys only - no data */ + +SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*); +SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*); +SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree*, int); + +SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue); +SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); + +SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p); + +/* +** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta +** should be one of the following values. The integer values are assigned +** to constants so that the offset of the corresponding field in an +** SQLite database header may be found using the following formula: +** +** offset = 36 + (idx * 4) +** +** For example, the free-page-count field is located at byte offset 36 of +** the database file header. The incr-vacuum-flag field is located at +** byte offset 64 (== 36+4*7). +*/ +#define BTREE_FREE_PAGE_COUNT 0 +#define BTREE_SCHEMA_VERSION 1 +#define BTREE_FILE_FORMAT 2 +#define BTREE_DEFAULT_CACHE_SIZE 3 +#define BTREE_LARGEST_ROOT_PAGE 4 +#define BTREE_TEXT_ENCODING 5 +#define BTREE_USER_VERSION 6 +#define BTREE_INCR_VACUUM 7 + +/* +** Values that may be OR'd together to form the second argument of an +** sqlite3BtreeCursorHints() call. +*/ +#define BTREE_BULKLOAD 0x00000001 + +SQLITE_PRIVATE int sqlite3BtreeCursor( + Btree*, /* BTree containing table to open */ + int iTable, /* Index of root page */ + int wrFlag, /* 1 for writing. 0 for read-only */ + struct KeyInfo*, /* First argument to compare function */ + BtCursor *pCursor /* Space to write cursor structure */ +); +SQLITE_PRIVATE int sqlite3BtreeCursorSize(void); +SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*); + +SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked( + BtCursor*, + UnpackedRecord *pUnKey, + i64 intKey, + int bias, + int *pRes +); +SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*, int*); +SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey, + const void *pData, int nData, + int nZero, int bias, int seekResult); +SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*); +SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes); +SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor*, i64 *pSize); +SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt); +SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt); +SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize); +SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64); +SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor*); + +SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*); +SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*); + +SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); +SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *); +SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *); +SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion); +SQLITE_PRIVATE void sqlite3BtreeCursorHints(BtCursor *, unsigned int mask); + +#ifndef NDEBUG +SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*); +#endif + +#ifndef SQLITE_OMIT_BTREECOUNT +SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *, i64 *); +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int); +SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*); +#endif + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *); +#endif + +/* +** If we are not using shared cache, then there is no need to +** use mutexes to access the BtShared structures. So make the +** Enter and Leave procedures no-ops. +*/ +#ifndef SQLITE_OMIT_SHARED_CACHE +SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*); +#else +# define sqlite3BtreeEnter(X) +# define sqlite3BtreeEnterAll(X) +#endif + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE +SQLITE_PRIVATE int sqlite3BtreeSharable(Btree*); +SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*); +SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*); +SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*); +#ifndef NDEBUG + /* These routines are used inside assert() statements only. */ +SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*); +SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*); +SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3*,int,Schema*); +#endif +#else + +# define sqlite3BtreeSharable(X) 0 +# define sqlite3BtreeLeave(X) +# define sqlite3BtreeEnterCursor(X) +# define sqlite3BtreeLeaveCursor(X) +# define sqlite3BtreeLeaveAll(X) + +# define sqlite3BtreeHoldsMutex(X) 1 +# define sqlite3BtreeHoldsAllMutexes(X) 1 +# define sqlite3SchemaMutexHeld(X,Y,Z) 1 +#endif + + +#endif /* _BTREE_H_ */ + +/************** End of btree.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include vdbe.h in the middle of sqliteInt.h ******************/ +/************** Begin file vdbe.h ********************************************/ +/* +** 2001 September 15 +** +** 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. +** +************************************************************************* +** Header file for the Virtual DataBase Engine (VDBE) +** +** This header defines the interface to the virtual database engine +** or VDBE. The VDBE implements an abstract machine that runs a +** simple program to access and modify the underlying database. +*/ +#ifndef _SQLITE_VDBE_H_ +#define _SQLITE_VDBE_H_ +/* #include */ + +/* +** A single VDBE is an opaque structure named "Vdbe". Only routines +** in the source file sqliteVdbe.c are allowed to see the insides +** of this structure. +*/ +typedef struct Vdbe Vdbe; + +/* +** The names of the following types declared in vdbeInt.h are required +** for the VdbeOp definition. +*/ +typedef struct VdbeFunc VdbeFunc; +typedef struct Mem Mem; +typedef struct SubProgram SubProgram; + +/* +** A single instruction of the virtual machine has an opcode +** and as many as three operands. The instruction is recorded +** as an instance of the following structure: +*/ +struct VdbeOp { + u8 opcode; /* What operation to perform */ + signed char p4type; /* One of the P4_xxx constants for p4 */ + u8 opflags; /* Mask of the OPFLG_* flags in opcodes.h */ + u8 p5; /* Fifth parameter is an unsigned character */ + int p1; /* First operand */ + int p2; /* Second parameter (often the jump destination) */ + int p3; /* The third parameter */ + union { /* fourth parameter */ + int i; /* Integer value if p4type==P4_INT32 */ + void *p; /* Generic pointer */ + char *z; /* Pointer to data for string (char array) types */ + i64 *pI64; /* Used when p4type is P4_INT64 */ + double *pReal; /* Used when p4type is P4_REAL */ + FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */ + VdbeFunc *pVdbeFunc; /* Used when p4type is P4_VDBEFUNC */ + CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */ + Mem *pMem; /* Used when p4type is P4_MEM */ + VTable *pVtab; /* Used when p4type is P4_VTAB */ + KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */ + int *ai; /* Used when p4type is P4_INTARRAY */ + SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */ + int (*xAdvance)(BtCursor *, int *); + } p4; +#ifdef SQLITE_DEBUG + char *zComment; /* Comment to improve readability */ +#endif +#ifdef VDBE_PROFILE + int cnt; /* Number of times this instruction was executed */ + u64 cycles; /* Total time spent executing this instruction */ +#endif +}; +typedef struct VdbeOp VdbeOp; + + +/* +** A sub-routine used to implement a trigger program. +*/ +struct SubProgram { + VdbeOp *aOp; /* Array of opcodes for sub-program */ + int nOp; /* Elements in aOp[] */ + int nMem; /* Number of memory cells required */ + int nCsr; /* Number of cursors required */ + int nOnce; /* Number of OP_Once instructions */ + void *token; /* id that may be used to recursive triggers */ + SubProgram *pNext; /* Next sub-program already visited */ +}; + +/* +** A smaller version of VdbeOp used for the VdbeAddOpList() function because +** it takes up less space. +*/ +struct VdbeOpList { + u8 opcode; /* What operation to perform */ + signed char p1; /* First operand */ + signed char p2; /* Second parameter (often the jump destination) */ + signed char p3; /* Third parameter */ +}; +typedef struct VdbeOpList VdbeOpList; + +/* +** Allowed values of VdbeOp.p4type +*/ +#define P4_NOTUSED 0 /* The P4 parameter is not used */ +#define P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */ +#define P4_STATIC (-2) /* Pointer to a static string */ +#define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */ +#define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */ +#define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */ +#define P4_VDBEFUNC (-7) /* P4 is a pointer to a VdbeFunc structure */ +#define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */ +#define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */ +#define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */ +#define P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */ +#define P4_REAL (-12) /* P4 is a 64-bit floating point value */ +#define P4_INT64 (-13) /* P4 is a 64-bit signed integer */ +#define P4_INT32 (-14) /* P4 is a 32-bit signed integer */ +#define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */ +#define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */ +#define P4_ADVANCE (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */ + +/* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure +** is made. That copy is freed when the Vdbe is finalized. But if the +** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used. It still +** gets freed when the Vdbe is finalized so it still should be obtained +** from a single sqliteMalloc(). But no copy is made and the calling +** function should *not* try to free the KeyInfo. +*/ +#define P4_KEYINFO_HANDOFF (-16) +#define P4_KEYINFO_STATIC (-17) + +/* +** The Vdbe.aColName array contains 5n Mem structures, where n is the +** number of columns of data returned by the statement. +*/ +#define COLNAME_NAME 0 +#define COLNAME_DECLTYPE 1 +#define COLNAME_DATABASE 2 +#define COLNAME_TABLE 3 +#define COLNAME_COLUMN 4 +#ifdef SQLITE_ENABLE_COLUMN_METADATA +# define COLNAME_N 5 /* Number of COLNAME_xxx symbols */ +#else +# ifdef SQLITE_OMIT_DECLTYPE +# define COLNAME_N 1 /* Store only the name */ +# else +# define COLNAME_N 2 /* Store the name and decltype */ +# endif +#endif + +/* +** The following macro converts a relative address in the p2 field +** of a VdbeOp structure into a negative number so that +** sqlite3VdbeAddOpList() knows that the address is relative. Calling +** the macro again restores the address. +*/ +#define ADDR(X) (-1-(X)) + +/* +** The makefile scans the vdbe.c source file and creates the "opcodes.h" +** header file that defines a number for each opcode used by the VDBE. +*/ +/************** Include opcodes.h in the middle of vdbe.h ********************/ +/************** Begin file opcodes.h *****************************************/ +/* Automatically generated. Do not edit */ +/* See the mkopcodeh.awk script for details */ +#define OP_Goto 1 +#define OP_Gosub 2 +#define OP_Return 3 +#define OP_Yield 4 +#define OP_HaltIfNull 5 +#define OP_Halt 6 +#define OP_Integer 7 +#define OP_Int64 8 +#define OP_Real 130 /* same as TK_FLOAT */ +#define OP_String8 94 /* same as TK_STRING */ +#define OP_String 9 +#define OP_Null 10 +#define OP_Blob 11 +#define OP_Variable 12 +#define OP_Move 13 +#define OP_Copy 14 +#define OP_SCopy 15 +#define OP_ResultRow 16 +#define OP_Concat 91 /* same as TK_CONCAT */ +#define OP_Add 86 /* same as TK_PLUS */ +#define OP_Subtract 87 /* same as TK_MINUS */ +#define OP_Multiply 88 /* same as TK_STAR */ +#define OP_Divide 89 /* same as TK_SLASH */ +#define OP_Remainder 90 /* same as TK_REM */ +#define OP_CollSeq 17 +#define OP_Function 18 +#define OP_BitAnd 82 /* same as TK_BITAND */ +#define OP_BitOr 83 /* same as TK_BITOR */ +#define OP_ShiftLeft 84 /* same as TK_LSHIFT */ +#define OP_ShiftRight 85 /* same as TK_RSHIFT */ +#define OP_AddImm 20 +#define OP_MustBeInt 21 +#define OP_RealAffinity 22 +#define OP_ToText 141 /* same as TK_TO_TEXT */ +#define OP_ToBlob 142 /* same as TK_TO_BLOB */ +#define OP_ToNumeric 143 /* same as TK_TO_NUMERIC*/ +#define OP_ToInt 144 /* same as TK_TO_INT */ +#define OP_ToReal 145 /* same as TK_TO_REAL */ +#define OP_Eq 76 /* same as TK_EQ */ +#define OP_Ne 75 /* same as TK_NE */ +#define OP_Lt 79 /* same as TK_LT */ +#define OP_Le 78 /* same as TK_LE */ +#define OP_Gt 77 /* same as TK_GT */ +#define OP_Ge 80 /* same as TK_GE */ +#define OP_Permutation 23 +#define OP_Compare 24 +#define OP_Jump 25 +#define OP_And 69 /* same as TK_AND */ +#define OP_Or 68 /* same as TK_OR */ +#define OP_Not 19 /* same as TK_NOT */ +#define OP_BitNot 93 /* same as TK_BITNOT */ +#define OP_Once 26 +#define OP_If 27 +#define OP_IfNot 28 +#define OP_IsNull 73 /* same as TK_ISNULL */ +#define OP_NotNull 74 /* same as TK_NOTNULL */ +#define OP_Column 29 +#define OP_Affinity 30 +#define OP_MakeRecord 31 +#define OP_Count 32 +#define OP_Savepoint 33 +#define OP_AutoCommit 34 +#define OP_Transaction 35 +#define OP_ReadCookie 36 +#define OP_SetCookie 37 +#define OP_VerifyCookie 38 +#define OP_OpenRead 39 +#define OP_OpenWrite 40 +#define OP_OpenAutoindex 41 +#define OP_OpenEphemeral 42 +#define OP_SorterOpen 43 +#define OP_OpenPseudo 44 +#define OP_Close 45 +#define OP_SeekLt 46 +#define OP_SeekLe 47 +#define OP_SeekGe 48 +#define OP_SeekGt 49 +#define OP_Seek 50 +#define OP_NotFound 51 +#define OP_Found 52 +#define OP_IsUnique 53 +#define OP_NotExists 54 +#define OP_Sequence 55 +#define OP_NewRowid 56 +#define OP_Insert 57 +#define OP_InsertInt 58 +#define OP_Delete 59 +#define OP_ResetCount 60 +#define OP_SorterCompare 61 +#define OP_SorterData 62 +#define OP_RowKey 63 +#define OP_RowData 64 +#define OP_Rowid 65 +#define OP_NullRow 66 +#define OP_Last 67 +#define OP_SorterSort 70 +#define OP_Sort 71 +#define OP_Rewind 72 +#define OP_SorterNext 81 +#define OP_Prev 92 +#define OP_Next 95 +#define OP_SorterInsert 96 +#define OP_IdxInsert 97 +#define OP_IdxDelete 98 +#define OP_IdxRowid 99 +#define OP_IdxLT 100 +#define OP_IdxGE 101 +#define OP_Destroy 102 +#define OP_Clear 103 +#define OP_CreateIndex 104 +#define OP_CreateTable 105 +#define OP_ParseSchema 106 +#define OP_LoadAnalysis 107 +#define OP_DropTable 108 +#define OP_DropIndex 109 +#define OP_DropTrigger 110 +#define OP_IntegrityCk 111 +#define OP_RowSetAdd 112 +#define OP_RowSetRead 113 +#define OP_RowSetTest 114 +#define OP_Program 115 +#define OP_Param 116 +#define OP_FkCounter 117 +#define OP_FkIfZero 118 +#define OP_MemMax 119 +#define OP_IfPos 120 +#define OP_IfNeg 121 +#define OP_IfZero 122 +#define OP_AggStep 123 +#define OP_AggFinal 124 +#define OP_Checkpoint 125 +#define OP_JournalMode 126 +#define OP_Vacuum 127 +#define OP_IncrVacuum 128 +#define OP_Expire 129 +#define OP_TableLock 131 +#define OP_VBegin 132 +#define OP_VCreate 133 +#define OP_VDestroy 134 +#define OP_VOpen 135 +#define OP_VFilter 136 +#define OP_VColumn 137 +#define OP_VNext 138 +#define OP_VRename 139 +#define OP_VUpdate 140 +#define OP_Pagecount 146 +#define OP_MaxPgcnt 147 +#define OP_Trace 148 +#define OP_Noop 149 +#define OP_Explain 150 + + +/* Properties such as "out2" or "jump" that are specified in +** comments following the "case" for each opcode in the vdbe.c +** are encoded into bitvectors as follows: +*/ +#define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */ +#define OPFLG_OUT2_PRERELEASE 0x0002 /* out2-prerelease: */ +#define OPFLG_IN1 0x0004 /* in1: P1 is an input */ +#define OPFLG_IN2 0x0008 /* in2: P2 is an input */ +#define OPFLG_IN3 0x0010 /* in3: P3 is an input */ +#define OPFLG_OUT2 0x0020 /* out2: P2 is an output */ +#define OPFLG_OUT3 0x0040 /* out3: P3 is an output */ +#define OPFLG_INITIALIZER {\ +/* 0 */ 0x00, 0x01, 0x01, 0x04, 0x04, 0x10, 0x00, 0x02,\ +/* 8 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x24,\ +/* 16 */ 0x00, 0x00, 0x00, 0x24, 0x04, 0x05, 0x04, 0x00,\ +/* 24 */ 0x00, 0x01, 0x01, 0x05, 0x05, 0x00, 0x00, 0x00,\ +/* 32 */ 0x02, 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00,\ +/* 40 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11,\ +/* 48 */ 0x11, 0x11, 0x08, 0x11, 0x11, 0x11, 0x11, 0x02,\ +/* 56 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 64 */ 0x00, 0x02, 0x00, 0x01, 0x4c, 0x4c, 0x01, 0x01,\ +/* 72 */ 0x01, 0x05, 0x05, 0x15, 0x15, 0x15, 0x15, 0x15,\ +/* 80 */ 0x15, 0x01, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,\ +/* 88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x01, 0x24, 0x02, 0x01,\ +/* 96 */ 0x08, 0x08, 0x00, 0x02, 0x01, 0x01, 0x02, 0x00,\ +/* 104 */ 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 112 */ 0x0c, 0x45, 0x15, 0x01, 0x02, 0x00, 0x01, 0x08,\ +/* 120 */ 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00,\ +/* 128 */ 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,\ +/* 136 */ 0x01, 0x00, 0x01, 0x00, 0x00, 0x04, 0x04, 0x04,\ +/* 144 */ 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00,} + +/************** End of opcodes.h *********************************************/ +/************** Continuing where we left off in vdbe.h ***********************/ + +/* +** Prototypes for the VDBE interface. See comments on the implementation +** for a description of what each of these routines does. +*/ +SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3*); +SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int); +SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int); +SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp); +SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*); +SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1); +SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2); +SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3); +SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5); +SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr); +SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr); +SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N); +SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int); +SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3*,Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,Parse*); +SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int); +SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*); +#ifdef SQLITE_DEBUG +SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int); +SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*); +#endif +SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*); +SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int); +SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*)); +SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*); +SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*); +SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int); +SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*); +SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*); +SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8); +SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int); +#ifndef SQLITE_OMIT_TRACE +SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*); +#endif + +SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*); +SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*); +SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo *, char *, int, char **); + +#ifndef SQLITE_OMIT_TRIGGER +SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *); +#endif + + +#ifndef NDEBUG +SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...); +# define VdbeComment(X) sqlite3VdbeComment X +SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...); +# define VdbeNoopComment(X) sqlite3VdbeNoopComment X +#else +# define VdbeComment(X) +# define VdbeNoopComment(X) +#endif + +#endif + +/************** End of vdbe.h ************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include pager.h in the middle of sqliteInt.h *****************/ +/************** Begin file pager.h *******************************************/ +/* +** 2001 September 15 +** +** 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 header file defines the interface that the sqlite page cache +** subsystem. The page cache subsystem reads and writes a file a page +** at a time and provides a journal for rollback. +*/ + +#ifndef _PAGER_H_ +#define _PAGER_H_ + +/* +** Default maximum size for persistent journal files. A negative +** value means no limit. This value may be overridden using the +** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit". +*/ +#ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT + #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1 +#endif + +/* +** The type used to represent a page number. The first page in a file +** is called page 1. 0 is used to represent "not a page". +*/ +typedef u32 Pgno; + +/* +** Each open file is managed by a separate instance of the "Pager" structure. +*/ +typedef struct Pager Pager; + +/* +** Handle type for pages. +*/ +typedef struct PgHdr DbPage; + +/* +** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is +** reserved for working around a windows/posix incompatibility). It is +** used in the journal to signify that the remainder of the journal file +** is devoted to storing a master journal name - there are no more pages to +** roll back. See comments for function writeMasterJournal() in pager.c +** for details. +*/ +#define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1)) + +/* +** Allowed values for the flags parameter to sqlite3PagerOpen(). +** +** NOTE: These values must match the corresponding BTREE_ values in btree.h. +*/ +#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ +#define PAGER_MEMORY 0x0002 /* In-memory database */ + +/* +** Valid values for the second argument to sqlite3PagerLockingMode(). +*/ +#define PAGER_LOCKINGMODE_QUERY -1 +#define PAGER_LOCKINGMODE_NORMAL 0 +#define PAGER_LOCKINGMODE_EXCLUSIVE 1 + +/* +** Numeric constants that encode the journalmode. +*/ +#define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */ +#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */ +#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */ +#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */ +#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */ +#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */ +#define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */ + +/* +** The remainder of this file contains the declarations of the functions +** that make up the Pager sub-system API. See source code comments for +** a detailed description of each routine. +*/ + +/* Open and close a Pager connection. */ +SQLITE_PRIVATE int sqlite3PagerOpen( + sqlite3_vfs*, + Pager **ppPager, + const char*, + int, + int, + int, + void(*)(DbPage*) +); +SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); + +/* Functions used to configure a Pager object. */ +SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *); +SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int); +SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int); +SQLITE_PRIVATE void sqlite3PagerShrink(Pager*); +SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int,int); +SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *, int); +SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager*); +SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager*); +SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64); +SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*); + +/* Functions used to obtain and release page references. */ +SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); +#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) +SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); +SQLITE_PRIVATE void sqlite3PagerRef(DbPage*); +SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*); + +/* Operations on page references. */ +SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*); +SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*); +SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int); +SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*); +SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *); +SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *); + +/* Functions used to manage pager transactions and savepoints. */ +SQLITE_PRIVATE void sqlite3PagerPagecount(Pager*, int*); +SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int); +SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager*); +SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*); +SQLITE_PRIVATE int sqlite3PagerRollback(Pager*); +SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n); +SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint); +SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager); + +#ifndef SQLITE_OMIT_WAL +SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int, int*, int*); +SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager); +SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen); +SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager); +#endif + +#ifdef SQLITE_ENABLE_ZIPVFS +SQLITE_PRIVATE int sqlite3PagerWalFramesize(Pager *pPager); +#endif + +/* Functions used to query pager state and configuration. */ +SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*); +SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*); +SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*, int); +SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*); +SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*); +SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*); +SQLITE_PRIVATE int sqlite3PagerNosync(Pager*); +SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*); +SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*); +SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *, int, int, int *); +SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *); +SQLITE_PRIVATE int sqlite3SectorSize(sqlite3_file *); + +/* Functions used to truncate the database file. */ +SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno); + +#if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_WAL) +SQLITE_PRIVATE void *sqlite3PagerCodec(DbPage *); +#endif + +/* Functions to support testing and debugging. */ +#if !defined(NDEBUG) || defined(SQLITE_TEST) +SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*); +SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*); +#endif +#ifdef SQLITE_TEST +SQLITE_PRIVATE int *sqlite3PagerStats(Pager*); +SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*); + void disable_simulated_io_errors(void); + void enable_simulated_io_errors(void); +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +#endif /* _PAGER_H_ */ + +/************** End of pager.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include pcache.h in the middle of sqliteInt.h ****************/ +/************** Begin file pcache.h ******************************************/ +/* +** 2008 August 05 +** +** 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 header file defines the interface that the sqlite page cache +** subsystem. +*/ + +#ifndef _PCACHE_H_ + +typedef struct PgHdr PgHdr; +typedef struct PCache PCache; + +/* +** Every page in the cache is controlled by an instance of the following +** structure. +*/ +struct PgHdr { + sqlite3_pcache_page *pPage; /* Pcache object page handle */ + void *pData; /* Page data */ + void *pExtra; /* Extra content */ + PgHdr *pDirty; /* Transient list of dirty pages */ + Pager *pPager; /* The pager this page is part of */ + Pgno pgno; /* Page number for this page */ +#ifdef SQLITE_CHECK_PAGES + u32 pageHash; /* Hash of page content */ +#endif + u16 flags; /* PGHDR flags defined below */ + + /********************************************************************** + ** Elements above are public. All that follows is private to pcache.c + ** and should not be accessed by other modules. + */ + i16 nRef; /* Number of users of this page */ + PCache *pCache; /* Cache that owns this page */ + + PgHdr *pDirtyNext; /* Next element in list of dirty pages */ + PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */ +}; + +/* Bit values for PgHdr.flags */ +#define PGHDR_DIRTY 0x002 /* Page has changed */ +#define PGHDR_NEED_SYNC 0x004 /* Fsync the rollback journal before + ** writing this page to the database */ +#define PGHDR_NEED_READ 0x008 /* Content is unread */ +#define PGHDR_REUSE_UNLIKELY 0x010 /* A hint that reuse is unlikely */ +#define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */ + +/* Initialize and shutdown the page cache subsystem */ +SQLITE_PRIVATE int sqlite3PcacheInitialize(void); +SQLITE_PRIVATE void sqlite3PcacheShutdown(void); + +/* Page cache buffer management: +** These routines implement SQLITE_CONFIG_PAGECACHE. +*/ +SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n); + +/* Create a new pager cache. +** Under memory stress, invoke xStress to try to make pages clean. +** Only clean and unpinned pages can be reclaimed. +*/ +SQLITE_PRIVATE void sqlite3PcacheOpen( + int szPage, /* Size of every page */ + int szExtra, /* Extra space associated with each page */ + int bPurgeable, /* True if pages are on backing store */ + int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */ + void *pStress, /* Argument to xStress */ + PCache *pToInit /* Preallocated space for the PCache */ +); + +/* Modify the page-size after the cache has been created. */ +SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *, int); + +/* Return the size in bytes of a PCache object. Used to preallocate +** storage space. +*/ +SQLITE_PRIVATE int sqlite3PcacheSize(void); + +/* One release per successful fetch. Page is pinned until released. +** Reference counted. +*/ +SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**); +SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*); + +SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */ +SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */ +SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */ +SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */ + +/* Change a page number. Used by incr-vacuum. */ +SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno); + +/* Remove all pages with pgno>x. Reset the cache if x==0 */ +SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x); + +/* Get a list of all dirty pages in the cache, sorted by page number */ +SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*); + +/* Reset and close the cache object */ +SQLITE_PRIVATE void sqlite3PcacheClose(PCache*); + +/* Clear flags from pages of the page cache */ +SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *); + +/* Discard the contents of the cache */ +SQLITE_PRIVATE void sqlite3PcacheClear(PCache*); + +/* Return the total number of outstanding page references */ +SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache*); + +/* Increment the reference count of an existing page */ +SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*); + +SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*); + +/* Return the total number of pages stored in the cache */ +SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*); + +#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) +/* Iterate through all dirty pages currently stored in the cache. This +** interface is only available if SQLITE_CHECK_PAGES is defined when the +** library is built. +*/ +SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)); +#endif + +/* Set and get the suggested cache-size for the specified pager-cache. +** +** If no global maximum is configured, then the system attempts to limit +** the total number of pages cached by purgeable pager-caches to the sum +** of the suggested cache-sizes. +*/ +SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int); +#ifdef SQLITE_TEST +SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *); +#endif + +/* Free up as much memory as possible from the page cache */ +SQLITE_PRIVATE void sqlite3PcacheShrink(PCache*); + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* Try to return memory used by the pcache module to the main memory heap */ +SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int); +#endif + +#ifdef SQLITE_TEST +SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*); +#endif + +SQLITE_PRIVATE void sqlite3PCacheSetDefault(void); + +#endif /* _PCACHE_H_ */ + +/************** End of pcache.h **********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + +/************** Include os.h in the middle of sqliteInt.h ********************/ +/************** Begin file os.h **********************************************/ +/* +** 2001 September 16 +** +** 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 header file (together with is companion C source-code file +** "os.c") attempt to abstract the underlying operating system so that +** the SQLite library will work on both POSIX and windows systems. +** +** This header file is #include-ed by sqliteInt.h and thus ends up +** being included by every source file. +*/ +#ifndef _SQLITE_OS_H_ +#define _SQLITE_OS_H_ + +/* +** Figure out if we are dealing with Unix, Windows, or some other +** operating system. After the following block of preprocess macros, +** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, and SQLITE_OS_OTHER +** will defined to either 1 or 0. One of the four will be 1. The other +** three will be 0. +*/ +#if defined(SQLITE_OS_OTHER) +# if SQLITE_OS_OTHER==1 +# undef SQLITE_OS_UNIX +# define SQLITE_OS_UNIX 0 +# undef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +# else +# undef SQLITE_OS_OTHER +# endif +#endif +#if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER) +# define SQLITE_OS_OTHER 0 +# ifndef SQLITE_OS_WIN +# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) +# define SQLITE_OS_WIN 1 +# define SQLITE_OS_UNIX 0 +# else +# define SQLITE_OS_WIN 0 +# define SQLITE_OS_UNIX 1 +# endif +# else +# define SQLITE_OS_UNIX 0 +# endif +#else +# ifndef SQLITE_OS_WIN +# define SQLITE_OS_WIN 0 +# endif +#endif + +#if SQLITE_OS_WIN +# include +#endif + +/* +** Determine if we are dealing with Windows NT. +** +** We ought to be able to determine if we are compiling for win98 or winNT +** using the _WIN32_WINNT macro as follows: +** +** #if defined(_WIN32_WINNT) +** # define SQLITE_OS_WINNT 1 +** #else +** # define SQLITE_OS_WINNT 0 +** #endif +** +** However, vs2005 does not set _WIN32_WINNT by default, as it ought to, +** so the above test does not work. We'll just assume that everything is +** winNT unless the programmer explicitly says otherwise by setting +** SQLITE_OS_WINNT to 0. +*/ +#if SQLITE_OS_WIN && !defined(SQLITE_OS_WINNT) +# define SQLITE_OS_WINNT 1 +#endif + +/* +** Determine if we are dealing with WindowsCE - which has a much +** reduced API. +*/ +#if defined(_WIN32_WCE) +# define SQLITE_OS_WINCE 1 +#else +# define SQLITE_OS_WINCE 0 +#endif + +/* +** Determine if we are dealing with WinRT, which provides only a subset of +** the full Win32 API. +*/ +#if !defined(SQLITE_OS_WINRT) +# define SQLITE_OS_WINRT 0 +#endif + +/* +** When compiled for WinCE or WinRT, there is no concept of the current +** directory. + */ +#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT +# define SQLITE_CURDIR 1 +#endif + +/* If the SET_FULLSYNC macro is not defined above, then make it +** a no-op +*/ +#ifndef SET_FULLSYNC +# define SET_FULLSYNC(x,y) +#endif + +/* +** The default size of a disk sector +*/ +#ifndef SQLITE_DEFAULT_SECTOR_SIZE +# define SQLITE_DEFAULT_SECTOR_SIZE 4096 +#endif + +/* +** Temporary files are named starting with this prefix followed by 16 random +** alphanumeric characters, and no file extension. They are stored in the +** OS's standard temporary file directory, and are deleted prior to exit. +** If sqlite is being embedded in another program, you may wish to change the +** prefix to reflect your program's name, so that if your program exits +** prematurely, old temporary files can be easily identified. This can be done +** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. +** +** 2006-10-31: The default prefix used to be "sqlite_". But then +** Mcafee started using SQLite in their anti-virus product and it +** started putting files with the "sqlite" name in the c:/temp folder. +** This annoyed many windows users. Those users would then do a +** Google search for "sqlite", find the telephone numbers of the +** developers and call to wake them up at night and complain. +** For this reason, the default name prefix is changed to be "sqlite" +** spelled backwards. So the temp files are still identified, but +** anybody smart enough to figure out the code is also likely smart +** enough to know that calling the developer will not help get rid +** of the file. +*/ +#ifndef SQLITE_TEMP_FILE_PREFIX +# define SQLITE_TEMP_FILE_PREFIX "etilqs_" +#endif + +/* +** The following values may be passed as the second argument to +** sqlite3OsLock(). The various locks exhibit the following semantics: +** +** SHARED: Any number of processes may hold a SHARED lock simultaneously. +** RESERVED: A single process may hold a RESERVED lock on a file at +** any time. Other processes may hold and obtain new SHARED locks. +** PENDING: A single process may hold a PENDING lock on a file at +** any one time. Existing SHARED locks may persist, but no new +** SHARED locks may be obtained by other processes. +** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. +** +** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a +** process that requests an EXCLUSIVE lock may actually obtain a PENDING +** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to +** sqlite3OsLock(). +*/ +#define NO_LOCK 0 +#define SHARED_LOCK 1 +#define RESERVED_LOCK 2 +#define PENDING_LOCK 3 +#define EXCLUSIVE_LOCK 4 + +/* +** File Locking Notes: (Mostly about windows but also some info for Unix) +** +** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because +** those functions are not available. So we use only LockFile() and +** UnlockFile(). +** +** LockFile() prevents not just writing but also reading by other processes. +** A SHARED_LOCK is obtained by locking a single randomly-chosen +** byte out of a specific range of bytes. The lock byte is obtained at +** random so two separate readers can probably access the file at the +** same time, unless they are unlucky and choose the same lock byte. +** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. +** There can only be one writer. A RESERVED_LOCK is obtained by locking +** a single byte of the file that is designated as the reserved lock byte. +** A PENDING_LOCK is obtained by locking a designated byte different from +** the RESERVED_LOCK byte. +** +** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, +** which means we can use reader/writer locks. When reader/writer locks +** are used, the lock is placed on the same range of bytes that is used +** for probabilistic locking in Win95/98/ME. Hence, the locking scheme +** will support two or more Win95 readers or two or more WinNT readers. +** But a single Win95 reader will lock out all WinNT readers and a single +** WinNT reader will lock out all other Win95 readers. +** +** The following #defines specify the range of bytes used for locking. +** SHARED_SIZE is the number of bytes available in the pool from which +** a random byte is selected for a shared lock. The pool of bytes for +** shared locks begins at SHARED_FIRST. +** +** The same locking strategy and +** byte ranges are used for Unix. This leaves open the possiblity of having +** clients on win95, winNT, and unix all talking to the same shared file +** and all locking correctly. To do so would require that samba (or whatever +** tool is being used for file sharing) implements locks correctly between +** windows and unix. I'm guessing that isn't likely to happen, but by +** using the same locking range we are at least open to the possibility. +** +** Locking in windows is manditory. For this reason, we cannot store +** actual data in the bytes used for locking. The pager never allocates +** the pages involved in locking therefore. SHARED_SIZE is selected so +** that all locks will fit on a single page even at the minimum page size. +** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE +** is set high so that we don't have to allocate an unused page except +** for very large databases. But one should test the page skipping logic +** by setting PENDING_BYTE low and running the entire regression suite. +** +** Changing the value of PENDING_BYTE results in a subtly incompatible +** file format. Depending on how it is changed, you might not notice +** the incompatibility right away, even running a full regression test. +** The default location of PENDING_BYTE is the first byte past the +** 1GB boundary. +** +*/ +#ifdef SQLITE_OMIT_WSD +# define PENDING_BYTE (0x40000000) +#else +# define PENDING_BYTE sqlite3PendingByte +#endif +#define RESERVED_BYTE (PENDING_BYTE+1) +#define SHARED_FIRST (PENDING_BYTE+2) +#define SHARED_SIZE 510 + +/* +** Wrapper around OS specific sqlite3_os_init() function. +*/ +SQLITE_PRIVATE int sqlite3OsInit(void); + +/* +** Functions for accessing sqlite3_file methods +*/ +SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file*); +SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); +SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size); +SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); +SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int); +SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*); +SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file*,int,void*); +#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0 +SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file *,int,int,int,void volatile **); +SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int); +SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id); +SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int); + + +/* +** Functions for accessing sqlite3_vfs methods +*/ +SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); +SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int); +SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut); +SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); +#ifndef SQLITE_OMIT_LOAD_EXTENSION +SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); +SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void); +SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *); +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ +SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *); +SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int); +SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *, sqlite3_int64*); + +/* +** Convenience functions for opening and closing files using +** sqlite3_malloc() to obtain space for the file-handle structure. +*/ +SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); +SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *); + +#endif /* _SQLITE_OS_H_ */ + +/************** End of os.h **************************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ +/************** Include mutex.h in the middle of sqliteInt.h *****************/ +/************** Begin file mutex.h *******************************************/ +/* +** 2007 August 28 +** +** 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 common header for all mutex implementations. +** The sqliteInt.h header #includes this file so that it is available +** to all source files. We break it out in an effort to keep the code +** better organized. +** +** NOTE: source files should *not* #include this header file directly. +** Source files should #include the sqliteInt.h file and let that file +** include this one indirectly. +*/ + + +/* +** Figure out what version of the code to use. The choices are +** +** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The +** mutexes implemention cannot be overridden +** at start-time. +** +** SQLITE_MUTEX_NOOP For single-threaded applications. No +** mutual exclusion is provided. But this +** implementation can be overridden at +** start-time. +** +** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix. +** +** SQLITE_MUTEX_W32 For multi-threaded applications on Win32. +*/ +#if !SQLITE_THREADSAFE +# define SQLITE_MUTEX_OMIT +#endif +#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP) +# if SQLITE_OS_UNIX +# define SQLITE_MUTEX_PTHREADS +# elif SQLITE_OS_WIN +# define SQLITE_MUTEX_W32 +# else +# define SQLITE_MUTEX_NOOP +# endif +#endif + +#ifdef SQLITE_MUTEX_OMIT +/* +** If this is a no-op implementation, implement everything as macros. +*/ +#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) +#define sqlite3_mutex_free(X) +#define sqlite3_mutex_enter(X) +#define sqlite3_mutex_try(X) SQLITE_OK +#define sqlite3_mutex_leave(X) +#define sqlite3_mutex_held(X) ((void)(X),1) +#define sqlite3_mutex_notheld(X) ((void)(X),1) +#define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8) +#define sqlite3MutexInit() SQLITE_OK +#define sqlite3MutexEnd() +#define MUTEX_LOGIC(X) +#else +#define MUTEX_LOGIC(X) X +#endif /* defined(SQLITE_MUTEX_OMIT) */ + +/************** End of mutex.h ***********************************************/ +/************** Continuing where we left off in sqliteInt.h ******************/ + + +/* +** Each database file to be accessed by the system is an instance +** of the following structure. There are normally two of these structures +** in the sqlite.aDb[] array. aDb[0] is the main database file and +** aDb[1] is the database file used to hold temporary tables. Additional +** databases may be attached. +*/ +struct Db { + char *zName; /* Name of this database */ + Btree *pBt; /* The B*Tree structure for this database file */ + u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ + u8 safety_level; /* How aggressive at syncing data to disk */ + Schema *pSchema; /* Pointer to database schema (possibly shared) */ +}; + +/* +** An instance of the following structure stores a database schema. +** +** Most Schema objects are associated with a Btree. The exception is +** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing. +** In shared cache mode, a single Schema object can be shared by multiple +** Btrees that refer to the same underlying BtShared object. +** +** Schema objects are automatically deallocated when the last Btree that +** references them is destroyed. The TEMP Schema is manually freed by +** sqlite3_close(). +* +** A thread must be holding a mutex on the corresponding Btree in order +** to access Schema content. This implies that the thread must also be +** holding a mutex on the sqlite3 connection pointer that owns the Btree. +** For a TEMP Schema, only the connection mutex is required. +*/ +struct Schema { + int schema_cookie; /* Database schema version number for this file */ + int iGeneration; /* Generation counter. Incremented with each change */ + Hash tblHash; /* All tables indexed by name */ + Hash idxHash; /* All (named) indices indexed by name */ + Hash trigHash; /* All triggers indexed by name */ + Hash fkeyHash; /* All foreign keys by referenced table name */ + Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ + u8 file_format; /* Schema format version for this file */ + u8 enc; /* Text encoding used by this database */ + u16 flags; /* Flags associated with this schema */ + int cache_size; /* Number of pages to use in the cache */ +}; + +/* +** These macros can be used to test, set, or clear bits in the +** Db.pSchema->flags field. +*/ +#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P)) +#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0) +#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P) +#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P) + +/* +** Allowed values for the DB.pSchema->flags field. +** +** The DB_SchemaLoaded flag is set after the database schema has been +** read into internal hash tables. +** +** DB_UnresetViews means that one or more views have column names that +** have been filled out. If the schema changes, these column names might +** changes and so the view will need to be reset. +*/ +#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ +#define DB_UnresetViews 0x0002 /* Some views have defined column names */ +#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */ + +/* +** The number of different kinds of things that can be limited +** using the sqlite3_limit() interface. +*/ +#define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1) + +/* +** Lookaside malloc is a set of fixed-size buffers that can be used +** to satisfy small transient memory allocation requests for objects +** associated with a particular database connection. The use of +** lookaside malloc provides a significant performance enhancement +** (approx 10%) by avoiding numerous malloc/free requests while parsing +** SQL statements. +** +** The Lookaside structure holds configuration information about the +** lookaside malloc subsystem. Each available memory allocation in +** the lookaside subsystem is stored on a linked list of LookasideSlot +** objects. +** +** Lookaside allocations are only allowed for objects that are associated +** with a particular database connection. Hence, schema information cannot +** be stored in lookaside because in shared cache mode the schema information +** is shared by multiple database connections. Therefore, while parsing +** schema information, the Lookaside.bEnabled flag is cleared so that +** lookaside allocations are not used to construct the schema objects. +*/ +struct Lookaside { + u16 sz; /* Size of each buffer in bytes */ + u8 bEnabled; /* False to disable new lookaside allocations */ + u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */ + int nOut; /* Number of buffers currently checked out */ + int mxOut; /* Highwater mark for nOut */ + int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */ + LookasideSlot *pFree; /* List of available buffers */ + void *pStart; /* First byte of available memory space */ + void *pEnd; /* First byte past end of available space */ +}; +struct LookasideSlot { + LookasideSlot *pNext; /* Next buffer in the list of free buffers */ +}; + +/* +** A hash table for function definitions. +** +** Hash each FuncDef structure into one of the FuncDefHash.a[] slots. +** Collisions are on the FuncDef.pHash chain. +*/ +struct FuncDefHash { + FuncDef *a[23]; /* Hash table for functions */ +}; + +/* +** Each database connection is an instance of the following structure. +*/ +struct sqlite3 { + sqlite3_vfs *pVfs; /* OS Interface */ + struct Vdbe *pVdbe; /* List of active virtual machines */ + CollSeq *pDfltColl; /* The default collating sequence (BINARY) */ + sqlite3_mutex *mutex; /* Connection mutex */ + Db *aDb; /* All backends */ + int nDb; /* Number of backends currently in use */ + int flags; /* Miscellaneous flags. See below */ + i64 lastRowid; /* ROWID of most recent insert (see above) */ + unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ + int errCode; /* Most recent error code (SQLITE_*) */ + int errMask; /* & result codes with this before returning */ + u16 dbOptFlags; /* Flags to enable/disable optimizations */ + u8 autoCommit; /* The auto-commit flag. */ + u8 temp_store; /* 1: file 2: memory 0: default */ + u8 mallocFailed; /* True if we have seen a malloc failure */ + u8 dfltLockMode; /* Default locking-mode for attached dbs */ + signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */ + u8 suppressErr; /* Do not issue error messages if true */ + u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */ + u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */ + int nextPagesize; /* Pagesize after VACUUM if >0 */ + u32 magic; /* Magic number for detect library misuse */ + int nChange; /* Value returned by sqlite3_changes() */ + int nTotalChange; /* Value returned by sqlite3_total_changes() */ + int aLimit[SQLITE_N_LIMIT]; /* Limits */ + struct sqlite3InitInfo { /* Information used during initialization */ + int newTnum; /* Rootpage of table being initialized */ + u8 iDb; /* Which db file is being initialized */ + u8 busy; /* TRUE if currently initializing */ + u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */ + } init; + int activeVdbeCnt; /* Number of VDBEs currently executing */ + int writeVdbeCnt; /* Number of active VDBEs that are writing */ + int vdbeExecCnt; /* Number of nested calls to VdbeExec() */ + int nExtension; /* Number of loaded extensions */ + void **aExtension; /* Array of shared library handles */ + void (*xTrace)(void*,const char*); /* Trace function */ + void *pTraceArg; /* Argument to the trace function */ + void (*xProfile)(void*,const char*,u64); /* Profiling function */ + void *pProfileArg; /* Argument to profile function */ + void *pCommitArg; /* Argument to xCommitCallback() */ + int (*xCommitCallback)(void*); /* Invoked at every commit. */ + void *pRollbackArg; /* Argument to xRollbackCallback() */ + void (*xRollbackCallback)(void*); /* Invoked at every commit. */ + void *pUpdateArg; + void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); +#ifndef SQLITE_OMIT_WAL + int (*xWalCallback)(void *, sqlite3 *, const char *, int); + void *pWalArg; +#endif + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); + void *pCollNeededArg; + sqlite3_value *pErr; /* Most recent error message */ + char *zErrMsg; /* Most recent error message (UTF-8 encoded) */ + char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */ + union { + volatile int isInterrupted; /* True if sqlite3_interrupt has been called */ + double notUsed1; /* Spacer */ + } u1; + Lookaside lookaside; /* Lookaside malloc configuration */ +#ifndef SQLITE_OMIT_AUTHORIZATION + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); + /* Access authorization function */ + void *pAuthArg; /* 1st argument to the access auth function */ +#endif +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + int (*xProgress)(void *); /* The progress callback */ + void *pProgressArg; /* Argument to the progress callback */ + int nProgressOps; /* Number of opcodes for progress callback */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nVTrans; /* Allocated size of aVTrans */ + Hash aModule; /* populated by sqlite3_create_module() */ + VtabCtx *pVtabCtx; /* Context for active vtab connect/create */ + VTable **aVTrans; /* Virtual tables with open transactions */ + VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */ +#endif + FuncDefHash aFunc; /* Hash table of connection functions */ + Hash aCollSeq; /* All collating sequences */ + BusyHandler busyHandler; /* Busy callback */ + Db aDbStatic[2]; /* Static space for the 2 default backends */ + Savepoint *pSavepoint; /* List of active savepoints */ + int busyTimeout; /* Busy handler timeout, in msec */ + int nSavepoint; /* Number of non-transaction savepoints */ + int nStatement; /* Number of nested statement-transactions */ + i64 nDeferredCons; /* Net deferred constraints this transaction. */ + int *pnBytesFreed; /* If not NULL, increment this in DbFree() */ + +#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY + /* The following variables are all protected by the STATIC_MASTER + ** mutex, not by sqlite3.mutex. They are used by code in notify.c. + ** + ** When X.pUnlockConnection==Y, that means that X is waiting for Y to + ** unlock so that it can proceed. + ** + ** When X.pBlockingConnection==Y, that means that something that X tried + ** tried to do recently failed with an SQLITE_LOCKED error due to locks + ** held by Y. + */ + sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */ + sqlite3 *pUnlockConnection; /* Connection to watch for unlock */ + void *pUnlockArg; /* Argument to xUnlockNotify */ + void (*xUnlockNotify)(void **, int); /* Unlock notify callback */ + sqlite3 *pNextBlocked; /* Next in list of all blocked connections */ +#endif +}; + +/* +** A macro to discover the encoding of a database. +*/ +#define ENC(db) ((db)->aDb[0].pSchema->enc) + +/* +** Possible values for the sqlite3.flags. +*/ +#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */ +#define SQLITE_InternChanges 0x00000002 /* Uncommitted Hash table changes */ +#define SQLITE_FullColNames 0x00000004 /* Show full column names on SELECT */ +#define SQLITE_ShortColNames 0x00000008 /* Show short columns names */ +#define SQLITE_CountRows 0x00000010 /* Count rows changed by INSERT, */ + /* DELETE, or UPDATE and return */ + /* the count using a callback. */ +#define SQLITE_NullCallback 0x00000020 /* Invoke the callback once if the */ + /* result set is empty */ +#define SQLITE_SqlTrace 0x00000040 /* Debug print SQL as it executes */ +#define SQLITE_VdbeListing 0x00000080 /* Debug listings of VDBE programs */ +#define SQLITE_WriteSchema 0x00000100 /* OK to update SQLITE_MASTER */ +#define SQLITE_VdbeAddopTrace 0x00000200 /* Trace sqlite3VdbeAddOp() calls */ +#define SQLITE_IgnoreChecks 0x00000400 /* Do not enforce check constraints */ +#define SQLITE_ReadUncommitted 0x0000800 /* For shared-cache mode */ +#define SQLITE_LegacyFileFmt 0x00001000 /* Create new databases in format 1 */ +#define SQLITE_FullFSync 0x00002000 /* Use full fsync on the backend */ +#define SQLITE_CkptFullFSync 0x00004000 /* Use full fsync for checkpoint */ +#define SQLITE_RecoveryMode 0x00008000 /* Ignore schema errors */ +#define SQLITE_ReverseOrder 0x00010000 /* Reverse unordered SELECTs */ +#define SQLITE_RecTriggers 0x00020000 /* Enable recursive triggers */ +#define SQLITE_ForeignKeys 0x00040000 /* Enforce foreign key constraints */ +#define SQLITE_AutoIndex 0x00080000 /* Enable automatic indexes */ +#define SQLITE_PreferBuiltin 0x00100000 /* Preference to built-in funcs */ +#define SQLITE_LoadExtension 0x00200000 /* Enable load_extension */ +#define SQLITE_EnableTrigger 0x00400000 /* True to enable triggers */ + +/* +** Bits of the sqlite3.dbOptFlags field that are used by the +** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface to +** selectively disable various optimizations. +*/ +#define SQLITE_QueryFlattener 0x0001 /* Query flattening */ +#define SQLITE_ColumnCache 0x0002 /* Column cache */ +#define SQLITE_GroupByOrder 0x0004 /* GROUPBY cover of ORDERBY */ +#define SQLITE_FactorOutConst 0x0008 /* Constant factoring */ +#define SQLITE_IdxRealAsInt 0x0010 /* Store REAL as INT in indices */ +#define SQLITE_DistinctOpt 0x0020 /* DISTINCT using indexes */ +#define SQLITE_CoverIdxScan 0x0040 /* Covering index scans */ +#define SQLITE_OrderByIdxJoin 0x0080 /* ORDER BY of joins via index */ +#define SQLITE_SubqCoroutine 0x0100 /* Evaluate subqueries as coroutines */ +#define SQLITE_Transitive 0x0200 /* Transitive constraints */ +#define SQLITE_AllOpts 0xffff /* All optimizations */ + +/* +** Macros for testing whether or not optimizations are enabled or disabled. +*/ +#ifndef SQLITE_OMIT_BUILTIN_TEST +#define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) +#define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0) +#else +#define OptimizationDisabled(db, mask) 0 +#define OptimizationEnabled(db, mask) 1 +#endif + +/* +** Possible values for the sqlite.magic field. +** The numbers are obtained at random and have no special meaning, other +** than being distinct from one another. +*/ +#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ +#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ +#define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */ +#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ +#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ +#define SQLITE_MAGIC_ZOMBIE 0x64cffc7f /* Close with last statement close */ + +/* +** Each SQL function is defined by an instance of the following +** structure. A pointer to this structure is stored in the sqlite.aFunc +** hash table. When multiple functions have the same name, the hash table +** points to a linked list of these structures. +*/ +struct FuncDef { + i16 nArg; /* Number of arguments. -1 means unlimited */ + u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */ + u8 flags; /* Some combination of SQLITE_FUNC_* */ + void *pUserData; /* User data parameter */ + FuncDef *pNext; /* Next function with same name */ + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ + void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ + void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */ + char *zName; /* SQL name of the function. */ + FuncDef *pHash; /* Next with a different name but the same hash */ + FuncDestructor *pDestructor; /* Reference counted destructor function */ +}; + +/* +** This structure encapsulates a user-function destructor callback (as +** configured using create_function_v2()) and a reference counter. When +** create_function_v2() is called to create a function with a destructor, +** a single object of this type is allocated. FuncDestructor.nRef is set to +** the number of FuncDef objects created (either 1 or 3, depending on whether +** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor +** member of each of the new FuncDef objects is set to point to the allocated +** FuncDestructor. +** +** Thereafter, when one of the FuncDef objects is deleted, the reference +** count on this object is decremented. When it reaches 0, the destructor +** is invoked and the FuncDestructor structure freed. +*/ +struct FuncDestructor { + int nRef; + void (*xDestroy)(void *); + void *pUserData; +}; + +/* +** Possible values for FuncDef.flags. Note that the _LENGTH and _TYPEOF +** values must correspond to OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG. There +** are assert() statements in the code to verify this. +*/ +#define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */ +#define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */ +#define SQLITE_FUNC_EPHEM 0x04 /* Ephemeral. Delete with VDBE */ +#define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */ +#define SQLITE_FUNC_COUNT 0x10 /* Built-in count(*) aggregate */ +#define SQLITE_FUNC_COALESCE 0x20 /* Built-in coalesce() or ifnull() function */ +#define SQLITE_FUNC_LENGTH 0x40 /* Built-in length() function */ +#define SQLITE_FUNC_TYPEOF 0x80 /* Built-in typeof() function */ + +/* +** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are +** used to create the initializers for the FuncDef structures. +** +** FUNCTION(zName, nArg, iArg, bNC, xFunc) +** Used to create a scalar function definition of a function zName +** implemented by C function xFunc that accepts nArg arguments. The +** value passed as iArg is cast to a (void*) and made available +** as the user-data (sqlite3_user_data()) for the function. If +** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set. +** +** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal) +** Used to create an aggregate function definition implemented by +** the C functions xStep and xFinal. The first four parameters +** are interpreted in the same way as the first 4 parameters to +** FUNCTION(). +** +** LIKEFUNC(zName, nArg, pArg, flags) +** Used to create a scalar function definition of a function zName +** that accepts nArg arguments and is implemented by a call to C +** function likeFunc. Argument pArg is cast to a (void *) and made +** available as the function user-data (sqlite3_user_data()). The +** FuncDef.flags variable is set to the value passed as the flags +** parameter. +*/ +#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ + {nArg, SQLITE_UTF8, (bNC*SQLITE_FUNC_NEEDCOLL), \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} +#define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ + {nArg, SQLITE_UTF8, (bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags, \ + SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0} +#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ + {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \ + pArg, 0, xFunc, 0, 0, #zName, 0, 0} +#define LIKEFUNC(zName, nArg, arg, flags) \ + {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0} +#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ + {nArg, SQLITE_UTF8, nc*SQLITE_FUNC_NEEDCOLL, \ + SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0} + +/* +** All current savepoints are stored in a linked list starting at +** sqlite3.pSavepoint. The first element in the list is the most recently +** opened savepoint. Savepoints are added to the list by the vdbe +** OP_Savepoint instruction. +*/ +struct Savepoint { + char *zName; /* Savepoint name (nul-terminated) */ + i64 nDeferredCons; /* Number of deferred fk violations */ + Savepoint *pNext; /* Parent savepoint (if any) */ +}; + +/* +** The following are used as the second parameter to sqlite3Savepoint(), +** and as the P1 argument to the OP_Savepoint instruction. +*/ +#define SAVEPOINT_BEGIN 0 +#define SAVEPOINT_RELEASE 1 +#define SAVEPOINT_ROLLBACK 2 + + +/* +** Each SQLite module (virtual table definition) is defined by an +** instance of the following structure, stored in the sqlite3.aModule +** hash table. +*/ +struct Module { + const sqlite3_module *pModule; /* Callback pointers */ + const char *zName; /* Name passed to create_module() */ + void *pAux; /* pAux passed to create_module() */ + void (*xDestroy)(void *); /* Module destructor function */ +}; + +/* +** information about each column of an SQL table is held in an instance +** of this structure. +*/ +struct Column { + char *zName; /* Name of this column */ + Expr *pDflt; /* Default value of this column */ + char *zDflt; /* Original text of the default value */ + char *zType; /* Data type for this column */ + char *zColl; /* Collating sequence. If NULL, use the default */ + u8 notNull; /* An OE_ code for handling a NOT NULL constraint */ + char affinity; /* One of the SQLITE_AFF_... values */ + u16 colFlags; /* Boolean properties. See COLFLAG_ defines below */ +}; + +/* Allowed values for Column.colFlags: +*/ +#define COLFLAG_PRIMKEY 0x0001 /* Column is part of the primary key */ +#define COLFLAG_HIDDEN 0x0002 /* A hidden column in a virtual table */ + +/* +** A "Collating Sequence" is defined by an instance of the following +** structure. Conceptually, a collating sequence consists of a name and +** a comparison routine that defines the order of that sequence. +** +** If CollSeq.xCmp is NULL, it means that the +** collating sequence is undefined. Indices built on an undefined +** collating sequence may not be read or written. +*/ +struct CollSeq { + char *zName; /* Name of the collating sequence, UTF-8 encoded */ + u8 enc; /* Text encoding handled by xCmp() */ + void *pUser; /* First argument to xCmp() */ + int (*xCmp)(void*,int, const void*, int, const void*); + void (*xDel)(void*); /* Destructor for pUser */ +}; + +/* +** A sort order can be either ASC or DESC. +*/ +#define SQLITE_SO_ASC 0 /* Sort in ascending order */ +#define SQLITE_SO_DESC 1 /* Sort in ascending order */ + +/* +** Column affinity types. +** +** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and +** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve +** the speed a little by numbering the values consecutively. +** +** But rather than start with 0 or 1, we begin with 'a'. That way, +** when multiple affinity types are concatenated into a string and +** used as the P4 operand, they will be more readable. +** +** Note also that the numeric types are grouped together so that testing +** for a numeric type is a single comparison. +*/ +#define SQLITE_AFF_TEXT 'a' +#define SQLITE_AFF_NONE 'b' +#define SQLITE_AFF_NUMERIC 'c' +#define SQLITE_AFF_INTEGER 'd' +#define SQLITE_AFF_REAL 'e' + +#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) + +/* +** The SQLITE_AFF_MASK values masks off the significant bits of an +** affinity value. +*/ +#define SQLITE_AFF_MASK 0x67 + +/* +** Additional bit values that can be ORed with an affinity without +** changing the affinity. +*/ +#define SQLITE_JUMPIFNULL 0x08 /* jumps if either operand is NULL */ +#define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */ +#define SQLITE_NULLEQ 0x80 /* NULL=NULL */ + +/* +** An object of this type is created for each virtual table present in +** the database schema. +** +** If the database schema is shared, then there is one instance of this +** structure for each database connection (sqlite3*) that uses the shared +** schema. This is because each database connection requires its own unique +** instance of the sqlite3_vtab* handle used to access the virtual table +** implementation. sqlite3_vtab* handles can not be shared between +** database connections, even when the rest of the in-memory database +** schema is shared, as the implementation often stores the database +** connection handle passed to it via the xConnect() or xCreate() method +** during initialization internally. This database connection handle may +** then be used by the virtual table implementation to access real tables +** within the database. So that they appear as part of the callers +** transaction, these accesses need to be made via the same database +** connection as that used to execute SQL operations on the virtual table. +** +** All VTable objects that correspond to a single table in a shared +** database schema are initially stored in a linked-list pointed to by +** the Table.pVTable member variable of the corresponding Table object. +** When an sqlite3_prepare() operation is required to access the virtual +** table, it searches the list for the VTable that corresponds to the +** database connection doing the preparing so as to use the correct +** sqlite3_vtab* handle in the compiled query. +** +** When an in-memory Table object is deleted (for example when the +** schema is being reloaded for some reason), the VTable objects are not +** deleted and the sqlite3_vtab* handles are not xDisconnect()ed +** immediately. Instead, they are moved from the Table.pVTable list to +** another linked list headed by the sqlite3.pDisconnect member of the +** corresponding sqlite3 structure. They are then deleted/xDisconnected +** next time a statement is prepared using said sqlite3*. This is done +** to avoid deadlock issues involving multiple sqlite3.mutex mutexes. +** Refer to comments above function sqlite3VtabUnlockList() for an +** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect +** list without holding the corresponding sqlite3.mutex mutex. +** +** The memory for objects of this type is always allocated by +** sqlite3DbMalloc(), using the connection handle stored in VTable.db as +** the first argument. +*/ +struct VTable { + sqlite3 *db; /* Database connection associated with this table */ + Module *pMod; /* Pointer to module implementation */ + sqlite3_vtab *pVtab; /* Pointer to vtab instance */ + int nRef; /* Number of pointers to this structure */ + u8 bConstraint; /* True if constraints are supported */ + int iSavepoint; /* Depth of the SAVEPOINT stack */ + VTable *pNext; /* Next in linked list (see above) */ +}; + +/* +** Each SQL table is represented in memory by an instance of the +** following structure. +** +** Table.zName is the name of the table. The case of the original +** CREATE TABLE statement is stored, but case is not significant for +** comparisons. +** +** Table.nCol is the number of columns in this table. Table.aCol is a +** pointer to an array of Column structures, one for each column. +** +** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of +** the column that is that key. Otherwise Table.iPKey is negative. Note +** that the datatype of the PRIMARY KEY must be INTEGER for this field to +** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of +** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid +** is generated for each row of the table. TF_HasPrimaryKey is set if +** the table has any PRIMARY KEY, INTEGER or otherwise. +** +** Table.tnum is the page number for the root BTree page of the table in the +** database file. If Table.iDb is the index of the database table backend +** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that +** holds temporary tables and indices. If TF_Ephemeral is set +** then the table is stored in a file that is automatically deleted +** when the VDBE cursor to the table is closed. In this case Table.tnum +** refers VDBE cursor number that holds the table open, not to the root +** page number. Transient tables are used to hold the results of a +** sub-query that appears instead of a real table name in the FROM clause +** of a SELECT statement. +*/ +struct Table { + char *zName; /* Name of the table or view */ + Column *aCol; /* Information about each column */ + Index *pIndex; /* List of SQL indexes on this table. */ + Select *pSelect; /* NULL for tables. Points to definition if a view. */ + FKey *pFKey; /* Linked list of all foreign keys in this table */ + char *zColAff; /* String defining the affinity of each column */ +#ifndef SQLITE_OMIT_CHECK + ExprList *pCheck; /* All CHECK constraints */ +#endif + tRowcnt nRowEst; /* Estimated rows in table - from sqlite_stat1 table */ + int tnum; /* Root BTree node for this table (see note above) */ + i16 iPKey; /* If not negative, use aCol[iPKey] as the primary key */ + i16 nCol; /* Number of columns in this table */ + u16 nRef; /* Number of pointers to this Table */ + u8 tabFlags; /* Mask of TF_* values */ + u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ +#ifndef SQLITE_OMIT_ALTERTABLE + int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + int nModuleArg; /* Number of arguments to the module */ + char **azModuleArg; /* Text of all module args. [0] is module name */ + VTable *pVTable; /* List of VTable objects. */ +#endif + Trigger *pTrigger; /* List of triggers stored in pSchema */ + Schema *pSchema; /* Schema that contains this table */ + Table *pNextZombie; /* Next on the Parse.pZombieTab list */ +}; + +/* +** Allowed values for Tabe.tabFlags. +*/ +#define TF_Readonly 0x01 /* Read-only system table */ +#define TF_Ephemeral 0x02 /* An ephemeral table */ +#define TF_HasPrimaryKey 0x04 /* Table has a primary key */ +#define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */ +#define TF_Virtual 0x10 /* Is a virtual table */ + + +/* +** Test to see whether or not a table is a virtual table. This is +** done as a macro so that it will be optimized out when virtual +** table support is omitted from the build. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +# define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0) +# define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) +#else +# define IsVirtual(X) 0 +# define IsHiddenColumn(X) 0 +#endif + +/* +** Each foreign key constraint is an instance of the following structure. +** +** A foreign key is associated with two tables. The "from" table is +** the table that contains the REFERENCES clause that creates the foreign +** key. The "to" table is the table that is named in the REFERENCES clause. +** Consider this example: +** +** CREATE TABLE ex1( +** a INTEGER PRIMARY KEY, +** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) +** ); +** +** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". +** +** Each REFERENCES clause generates an instance of the following structure +** which is attached to the from-table. The to-table need not exist when +** the from-table is created. The existence of the to-table is not checked. +*/ +struct FKey { + Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */ + FKey *pNextFrom; /* Next foreign key in pFrom */ + char *zTo; /* Name of table that the key points to (aka: Parent) */ + FKey *pNextTo; /* Next foreign key on table named zTo */ + FKey *pPrevTo; /* Previous foreign key on table named zTo */ + int nCol; /* Number of columns in this key */ + /* EV: R-30323-21917 */ + u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ + u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */ + Trigger *apTrigger[2]; /* Triggers for aAction[] actions */ + struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ + int iFrom; /* Index of column in pFrom */ + char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */ + } aCol[1]; /* One entry for each of nCol column s */ +}; + +/* +** SQLite supports many different ways to resolve a constraint +** error. ROLLBACK processing means that a constraint violation +** causes the operation in process to fail and for the current transaction +** to be rolled back. ABORT processing means the operation in process +** fails and any prior changes from that one operation are backed out, +** but the transaction is not rolled back. FAIL processing means that +** the operation in progress stops and returns an error code. But prior +** changes due to the same operation are not backed out and no rollback +** occurs. IGNORE means that the particular row that caused the constraint +** error is not inserted or updated. Processing continues and no error +** is returned. REPLACE means that preexisting database rows that caused +** a UNIQUE constraint violation are removed so that the new insert or +** update can proceed. Processing continues and no error is reported. +** +** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. +** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the +** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign +** key is set to NULL. CASCADE means that a DELETE or UPDATE of the +** referenced table row is propagated into the row that holds the +** foreign key. +** +** The following symbolic values are used to record which type +** of action to take. +*/ +#define OE_None 0 /* There is no constraint to check */ +#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ +#define OE_Abort 2 /* Back out changes but do no rollback transaction */ +#define OE_Fail 3 /* Stop the operation but leave all prior changes */ +#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ +#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ + +#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ +#define OE_SetNull 7 /* Set the foreign key value to NULL */ +#define OE_SetDflt 8 /* Set the foreign key value to its default */ +#define OE_Cascade 9 /* Cascade the changes */ + +#define OE_Default 99 /* Do whatever the default action is */ + + +/* +** An instance of the following structure is passed as the first +** argument to sqlite3VdbeKeyCompare and is used to control the +** comparison of the two index keys. +*/ +struct KeyInfo { + sqlite3 *db; /* The database connection */ + u8 enc; /* Text encoding - one of the SQLITE_UTF* values */ + u16 nField; /* Number of entries in aColl[] */ + u8 *aSortOrder; /* Sort order for each column. May be NULL */ + CollSeq *aColl[1]; /* Collating sequence for each term of the key */ +}; + +/* +** An instance of the following structure holds information about a +** single index record that has already been parsed out into individual +** values. +** +** A record is an object that contains one or more fields of data. +** Records are used to store the content of a table row and to store +** the key of an index. A blob encoding of a record is created by +** the OP_MakeRecord opcode of the VDBE and is disassembled by the +** OP_Column opcode. +** +** This structure holds a record that has already been disassembled +** into its constituent fields. +*/ +struct UnpackedRecord { + KeyInfo *pKeyInfo; /* Collation and sort-order information */ + u16 nField; /* Number of entries in apMem[] */ + u8 flags; /* Boolean settings. UNPACKED_... below */ + i64 rowid; /* Used by UNPACKED_PREFIX_SEARCH */ + Mem *aMem; /* Values */ +}; + +/* +** Allowed values of UnpackedRecord.flags +*/ +#define UNPACKED_INCRKEY 0x01 /* Make this key an epsilon larger */ +#define UNPACKED_PREFIX_MATCH 0x02 /* A prefix match is considered OK */ +#define UNPACKED_PREFIX_SEARCH 0x04 /* Ignore final (rowid) field */ + +/* +** Each SQL index is represented in memory by an +** instance of the following structure. +** +** The columns of the table that are to be indexed are described +** by the aiColumn[] field of this structure. For example, suppose +** we have the following table and index: +** +** CREATE TABLE Ex1(c1 int, c2 int, c3 text); +** CREATE INDEX Ex2 ON Ex1(c3,c1); +** +** In the Table structure describing Ex1, nCol==3 because there are +** three columns in the table. In the Index structure describing +** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. +** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the +** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. +** The second column to be indexed (c1) has an index of 0 in +** Ex1.aCol[], hence Ex2.aiColumn[1]==0. +** +** The Index.onError field determines whether or not the indexed columns +** must be unique and what to do if they are not. When Index.onError=OE_None, +** it means this is not a unique index. Otherwise it is a unique index +** and the value of Index.onError indicate the which conflict resolution +** algorithm to employ whenever an attempt is made to insert a non-unique +** element. +*/ +struct Index { + char *zName; /* Name of this index */ + int *aiColumn; /* Which columns are used by this index. 1st is 0 */ + tRowcnt *aiRowEst; /* From ANALYZE: Est. rows selected by each column */ + Table *pTable; /* The SQL table being indexed */ + char *zColAff; /* String defining the affinity of each column */ + Index *pNext; /* The next index associated with the same table */ + Schema *pSchema; /* Schema containing this index */ + u8 *aSortOrder; /* for each column: True==DESC, False==ASC */ + char **azColl; /* Array of collation sequence names for index */ + int tnum; /* DB Page containing root of this index */ + u16 nColumn; /* Number of columns in table used by this index */ + u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + unsigned autoIndex:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */ + unsigned bUnordered:1; /* Use this index for == or IN queries only */ +#ifdef SQLITE_ENABLE_STAT3 + int nSample; /* Number of elements in aSample[] */ + tRowcnt avgEq; /* Average nEq value for key values not in aSample */ + IndexSample *aSample; /* Samples of the left-most key */ +#endif +}; + +/* +** Each sample stored in the sqlite_stat3 table is represented in memory +** using a structure of this type. See documentation at the top of the +** analyze.c source file for additional information. +*/ +struct IndexSample { + union { + char *z; /* Value if eType is SQLITE_TEXT or SQLITE_BLOB */ + double r; /* Value if eType is SQLITE_FLOAT */ + i64 i; /* Value if eType is SQLITE_INTEGER */ + } u; + u8 eType; /* SQLITE_NULL, SQLITE_INTEGER ... etc. */ + int nByte; /* Size in byte of text or blob. */ + tRowcnt nEq; /* Est. number of rows where the key equals this sample */ + tRowcnt nLt; /* Est. number of rows where key is less than this sample */ + tRowcnt nDLt; /* Est. number of distinct keys less than this sample */ +}; + +/* +** Each token coming out of the lexer is an instance of +** this structure. Tokens are also used as part of an expression. +** +** Note if Token.z==0 then Token.dyn and Token.n are undefined and +** may contain random values. Do not make any assumptions about Token.dyn +** and Token.n when Token.z==0. +*/ +struct Token { + const char *z; /* Text of the token. Not NULL-terminated! */ + unsigned int n; /* Number of characters in this token */ +}; + +/* +** An instance of this structure contains information needed to generate +** code for a SELECT that contains aggregate functions. +** +** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a +** pointer to this structure. The Expr.iColumn field is the index in +** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate +** code for that node. +** +** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the +** original Select structure that describes the SELECT statement. These +** fields do not need to be freed when deallocating the AggInfo structure. +*/ +struct AggInfo { + u8 directMode; /* Direct rendering mode means take data directly + ** from source tables rather than from accumulators */ + u8 useSortingIdx; /* In direct mode, reference the sorting index rather + ** than the source table */ + int sortingIdx; /* Cursor number of the sorting index */ + int sortingIdxPTab; /* Cursor number of pseudo-table */ + int nSortingColumn; /* Number of columns in the sorting index */ + ExprList *pGroupBy; /* The group by clause */ + struct AggInfo_col { /* For each column used in source tables */ + Table *pTab; /* Source table */ + int iTable; /* Cursor number of the source table */ + int iColumn; /* Column number within the source table */ + int iSorterColumn; /* Column number in the sorting index */ + int iMem; /* Memory location that acts as accumulator */ + Expr *pExpr; /* The original expression */ + } *aCol; + int nColumn; /* Number of used entries in aCol[] */ + int nAccumulator; /* Number of columns that show through to the output. + ** Additional columns are used only as parameters to + ** aggregate functions */ + struct AggInfo_func { /* For each aggregate function */ + Expr *pExpr; /* Expression encoding the function */ + FuncDef *pFunc; /* The aggregate function implementation */ + int iMem; /* Memory location that acts as accumulator */ + int iDistinct; /* Ephemeral table used to enforce DISTINCT */ + } *aFunc; + int nFunc; /* Number of entries in aFunc[] */ +}; + +/* +** The datatype ynVar is a signed integer, either 16-bit or 32-bit. +** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater +** than 32767 we have to make it 32-bit. 16-bit is preferred because +** it uses less memory in the Expr object, which is a big memory user +** in systems with lots of prepared statements. And few applications +** need more than about 10 or 20 variables. But some extreme users want +** to have prepared statements with over 32767 variables, and for them +** the option is available (at compile-time). +*/ +#if SQLITE_MAX_VARIABLE_NUMBER<=32767 +typedef i16 ynVar; +#else +typedef int ynVar; +#endif + +/* +** Each node of an expression in the parse tree is an instance +** of this structure. +** +** Expr.op is the opcode. The integer parser token codes are reused +** as opcodes here. For example, the parser defines TK_GE to be an integer +** code representing the ">=" operator. This same integer code is reused +** to represent the greater-than-or-equal-to operator in the expression +** tree. +** +** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB, +** or TK_STRING), then Expr.token contains the text of the SQL literal. If +** the expression is a variable (TK_VARIABLE), then Expr.token contains the +** variable name. Finally, if the expression is an SQL function (TK_FUNCTION), +** then Expr.token contains the name of the function. +** +** Expr.pRight and Expr.pLeft are the left and right subexpressions of a +** binary operator. Either or both may be NULL. +** +** Expr.x.pList is a list of arguments if the expression is an SQL function, +** a CASE expression or an IN expression of the form " IN (, ...)". +** Expr.x.pSelect is used if the expression is a sub-select or an expression of +** the form " IN (SELECT ...)". If the EP_xIsSelect bit is set in the +** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is +** valid. +** +** An expression of the form ID or ID.ID refers to a column in a table. +** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is +** the integer cursor number of a VDBE cursor pointing to that table and +** Expr.iColumn is the column number for the specific column. If the +** expression is used as a result in an aggregate SELECT, then the +** value is also stored in the Expr.iAgg column in the aggregate so that +** it can be accessed after all aggregates are computed. +** +** If the expression is an unbound variable marker (a question mark +** character '?' in the original SQL) then the Expr.iTable holds the index +** number for that variable. +** +** If the expression is a subquery then Expr.iColumn holds an integer +** register number containing the result of the subquery. If the +** subquery gives a constant result, then iTable is -1. If the subquery +** gives a different answer at different times during statement processing +** then iTable is the address of a subroutine that computes the subquery. +** +** If the Expr is of type OP_Column, and the table it is selecting from +** is a disk table or the "old.*" pseudo-table, then pTab points to the +** corresponding table definition. +** +** ALLOCATION NOTES: +** +** Expr objects can use a lot of memory space in database schema. To +** help reduce memory requirements, sometimes an Expr object will be +** truncated. And to reduce the number of memory allocations, sometimes +** two or more Expr objects will be stored in a single memory allocation, +** together with Expr.zToken strings. +** +** If the EP_Reduced and EP_TokenOnly flags are set when +** an Expr object is truncated. When EP_Reduced is set, then all +** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees +** are contained within the same memory allocation. Note, however, that +** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately +** allocated, regardless of whether or not EP_Reduced is set. +*/ +struct Expr { + u8 op; /* Operation performed by this node */ + char affinity; /* The affinity of the column or 0 if not a column */ + u16 flags; /* Various flags. EP_* See below */ + union { + char *zToken; /* Token value. Zero terminated and dequoted */ + int iValue; /* Non-negative integer value if EP_IntValue */ + } u; + + /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no + ** space is allocated for the fields below this point. An attempt to + ** access them will result in a segfault or malfunction. + *********************************************************************/ + + Expr *pLeft; /* Left subnode */ + Expr *pRight; /* Right subnode */ + union { + ExprList *pList; /* Function arguments or in " IN ( IN (