Lines Matching refs:P
2714 ** ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X
2715 ** that might be invoked with argument P whenever
3038 ** ^A call to this routine stores N bytes of randomness into buffer P.
3039 ** ^The P parameter can be a NULL pointer.
3042 ** call had N less than one or a NULL pointer for P, then the PRNG is
3046 ** non-NULL P then the pseudo-randomness is generated
3050 void sqlite3_randomness(int N, void *P);
3260 ** to [sqlite3_trace_v2(D,M,X,P)] is an OR-ed combination of one or more of
3266 ** ^A trace callback has four arguments: xCallback(T,C,P,X).
3270 ** The P and X arguments are pointers whose meanings depend on T.
3277 ** trigger subprogram. ^The P argument is a pointer to the
3283 ** [sqlite3_expanded_sql(P)] otherwise.
3288 ** ^The P argument is a pointer to the [prepared statement] and the
3296 ** ^The P argument is a pointer to the [prepared statement] and the
3302 ** ^The P argument is a pointer to the [database connection] object
3315 ** ^The sqlite3_trace_v2(D,M,X,P) interface registers a trace callback
3317 ** and context pointer P. ^If the X callback is
3330 ** ^A trace callback is invoked with four arguments: callback(T,C,P,X).
3334 ** The P and X arguments are pointers whose meanings depend on T.
3351 ** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback
3357 ** ^The parameter P is passed through as the only parameter to the
3689 ** and if P is the name of the query parameter, then
3690 ** sqlite3_uri_parameter(F,P) returns the value of the P
3691 ** parameter if it exists or a NULL pointer if P does not appear as a
3692 ** query parameter on F. If P is a query parameter of F and it
3693 ** has no explicit value, then sqlite3_uri_parameter(F,P) returns
3696 ** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean
3698 ** of P. The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the
3699 ** value of query parameter P is one of "yes", "true", or "on" in any
3701 ** sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of
3702 ** query parameter P is one of "no", "false", or "off" in any case or
3703 ** if the value begins with a numeric zero. If P is not a query
3704 ** parameter on F or if the value of P does not match any of the
3705 ** above, then sqlite3_uri_boolean(F,P,B) returns (B!=0).
3707 ** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a
3708 ** 64-bit signed integer and returns that integer, or D if P does not
3709 ** exist. If the value of P is something other than an integer, then
3719 ** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and
3720 ** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and
3796 ** The sqlite3_create_filename(D,J,W,N,P) allocates memory to hold a version of
3798 ** with N URI parameters key/values pairs in the array P. The result from
3799 ** sqlite3_create_filename(D,J,W,N,P) is a pointer to a database filename that
3814 ** The P parameter in sqlite3_create_filename(D,J,W,N,P) should be an array
3816 ** to a key and value for a query parameter. The P parameter may be a NULL
3817 ** pointer if N is zero. None of the 2*N pointers in the P array may be
3819 ** None of the D, J, or W parameters to sqlite3_create_filename(D,J,W,N,P) may
4236 ** ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8
4237 ** SQL text used to create [prepared statement] P if P was
4240 ** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8
4241 ** string containing the SQL text of prepared statement P with
4243 ** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8
4244 ** string containing the normalized SQL text of prepared statement P. The
4263 ** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P)
4266 ** ^The string returned by sqlite3_expanded_sql(P), on the other hand,
4529 ** ^The sqlite3_bind_pointer(S,I,P,T,D) routine causes the I-th parameter in
4531 ** associated with the pointer P of type T. ^D is either a NULL pointer or
4532 ** a pointer to a destructor function for P. ^SQLite will invoke the
4533 ** destructor D with a single argument of P when it is finished using
4534 ** P. The T parameter should be a static string, preferably a string
4600 ** ^The sqlite3_bind_parameter_name(P,N) interface returns
4601 ** the name of the N-th [SQL parameter] in the [prepared statement] P.
4868 ** ^The sqlite3_data_count(P) interface returns the number of columns in the
4869 ** current row of the result set of [prepared statement] P.
4870 ** ^If prepared statement P does not have results ready to return
4872 ** interfaces) then sqlite3_data_count(P) returns 0.
4873 ** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer.
4874 ** ^The sqlite3_data_count(P) routine returns 0 if the previous call to
4875 ** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P)
4876 ** will return non-zero if previous call to [sqlite3_step](P) returned
5520 ** using [sqlite3_bind_pointer(S,I,P,X,D)] or [sqlite3_result_pointer(C,P,X,D)]
5522 ** then sqlite3_value_pointer(V,Y) will return the pointer P. ^Otherwise,
5739 ** associated by the sqlite3_set_auxdata(C,N,P,X) function with the Nth argument
5745 ** ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th
5747 ** calls to sqlite3_get_auxdata(C,N) return P from the most recent
5748 ** sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or
5750 ** ^After each call to sqlite3_set_auxdata(C,N,P,X) where X is not NULL,
5751 ** SQLite will invoke the destructor function X with parameter P exactly
5763 ** sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
5766 ** function implementation should not make any use of P after
5934 ** ^The sqlite3_result_pointer(C,P,T,D) interface sets the result to an
5936 ** also associates the host-language pointer P or type T with that
5940 ** for the P parameter. ^SQLite invokes D with P as its only argument
5941 ** when SQLite is finished with P. The T parameter should be a static
6472 ** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions
6473 ** return the P argument from the previous call of the same function
6510 ** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback
6512 ** file. ^The callback is passed a copy of the generic data pointer (P),
6531 ** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional
6532 ** destructor for the P parameter. ^If X is not NULL, then X(P) is
6539 ** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer,
6613 ** ^The sqlite3_update_hook(D,C,P) function
6614 ** returns the P argument from the previous call
9196 ** ^The [sqlite3_strglob(P,X)] interface returns zero if and only if
9197 ** string X matches the [GLOB] pattern P.
9199 ** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the
9200 ** SQL dialect understood by SQLite. ^The [sqlite3_strglob(P,X)] function
9213 ** ^The [sqlite3_strlike(P,X,E)] interface returns zero if and only if
9214 ** string X matches the [LIKE] pattern P with escape character E.
9216 ** [sqlite3_strlike(P,X,E)] is the same as for the "X LIKE P ESCAPE E"
9217 ** operator in the SQL dialect understood by SQLite. ^For "X LIKE P" without
9218 ** the ESCAPE clause, set the E parameter of [sqlite3_strlike(P,X,E)] to 0.
9219 ** ^As with the LIKE operator, the [sqlite3_strlike(P,X,E)] function is case
9223 ** ^The [sqlite3_strlike(P,X,E)] function matches Unicode characters, though
9722 ** ^A call to sqlite3_vtab_in(P,N,-1) will return true (non-zero)
9723 ** if and only if the [sqlite3_index_info|P->aConstraint][N] constraint
9730 ** ^A call to sqlite3_vtab_in(P,N,F) with F==1 or F==0 indicates
9738 ** ^The sqlite3_vtab_in(P,N,F) interface can be invoked multiple times
9739 ** within the same xBestIndex method call. ^For any given P,N pair,
9740 ** the return value from sqlite3_vtab_in(P,N,F) will always be the same
9751 ** <li><p> The P->aConstraintUsage[N].argvIndex value is set to a positive
9755 ** <li><p> The last call to sqlite3_vtab_in(P,N,F) for which F was
9777 ** The X parameter in a call to sqlite3_vtab_in_first(X,P) or
9778 ** sqlite3_vtab_in_next(X,P) must be one of the parameters to the
9802 ** ^On success, the sqlite3_vtab_in_first(X,P) and sqlite3_vtab_in_next(X,P)
9803 ** routines return SQLITE_OK and set *P to point to the first or next value
9805 ** right hand side of the IN constraint, then *P is set to NULL and these
9826 ** ^When the sqlite3_vtab_rhs_value(P,J,V) interface is invoked from within
9827 ** the [xBestIndex] method of a [virtual table] implementation, with P being
9829 ** J being a 0-based index into P->aConstraint[], then this routine
9833 ** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if
9834 ** and only if *V is set to a value. ^The sqlite3_vtab_rhs_value(P,J,V)
10071 ** ^The [sqlite3_preupdate_old(D,N,P)] interface writes into P a pointer to
10077 ** behavior is undefined. The [sqlite3_value] that P points to
10080 ** ^The [sqlite3_preupdate_new(D,N,P)] interface writes into P a pointer to
10086 ** behavior is undefined. The [sqlite3_value] that P points to
10168 ** ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a
10171 ** [sqlite3_snapshot_get(D,S,P)] interface writes a pointer to the newly
10172 ** created [sqlite3_snapshot] object into *P and returns SQLITE_OK.
10178 ** called, SQLITE_ERROR is returned. The final value of *P is undefined
10217 ** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read
10220 ** historical [snapshot] P, rather than the most recent change to the
10225 ** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there
10242 ** read transaction is now open on database snapshot P.
10244 ** ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the
10266 ** ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P.
10333 ** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory
10335 ** If P is not a NULL pointer, then the size of the database in bytes
10336 ** is written into *P.
10355 ** The size of the database is written into *P even if the
10359 ** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the
10377 ** the F argument to [sqlite3_serialize(D,S,P,F)].
10392 ** The sqlite3_deserialize(D,S,P,N,M,F) interface causes the
10395 ** in P. The serialized database P is N bytes in size. M is the size of
10396 ** the buffer P, which might be larger than N. If M is larger than N, and
10412 ** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the
10415 ** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the
10417 ** [sqlite3_free()] is invoked on argument P prior to returning.
10435 ** the [sqlite3_deserialize(D,S,P,N,M,F)] interface.
10438 ** in the P argument is held in memory obtained from [sqlite3_malloc64()]