Today (Saturday) We will make some minor tuning adjustments to MySQL.

You may experience 2 up to 10 seconds "glitch time" when we restart MySQL. We expect to make these adjustments around 1AM Eastern Daylight Saving Time (EDT) US.

string(3)						     Library Functions Manual							 string(3)

Name
       strcasecmp, strncasecmp, strcat, strncat, strcmp, strncmp, strcpy, strncpy, strlen, strchr, strrchr, strpbrk, strspn, strcspn, strstr, str-
       tok, index, rindex - string operations

Syntax
       #include <strings.h>

	      or

       #include <string.h>

       strcasecmp(s1, s2)
       char *s1, *s2;

       strncasecmp(s1, s2, n)
       char *s1, *s2;

       char *strcat(s1, s2)
       char *s1, *s2;

       char *strncat(s1, s2, n)
       char *s1, *s2;

       int strcmp(s1, s2)
       unsigned char *s1, *s2;

       int strncmp(s1, s2, n)
       unsigned char *s1, *s2;
       int n

       char *strcpy(s1, s2)
       char *s1, *s2;

       char *strncpy(s1, s2, n)
       char *s1, *s2;
       int n

       size_t strlen(s)
       char *s;

       char *strchr(s, c)
       char *s;
       int c;

       char *strrchr(s, c)
       char *s;
       int c;

       char *strpbrk(s1, s2)
       char *s1, *s2;

       size_t strspn(s1, s2)
       char *s1, *s2;

       size_t strcspn(s1, s2)
       char *s1, *s2;

       char *strtok(s1, s2)
       char *s1, *s2;

       char *index(s, c)
       char *s, c;

       char *rindex(s, c)
       char *s, c;

       char *strstr(s1, s2)
       char *s1, *s2;

Description
       The arguments s1, s2, and s point to strings (arrays of characters terminated by a null character).   The  functions  and  subroutines  all
       alter s1.  These functions do not check for overflow of the array pointed to by s1.

       The  subroutine appends a copy of string s2 to the end of string s1.  The subroutine copies at most n characters.  Both return a pointer to
       the null-terminated result.

       The subroutine compares its arguments and returns an integer greater than, equal to, or less than 0, according as s1  is  lexicographically
       greater	than,  equal to, or less than s2.  The subroutine makes the same comparison but looks at at most n characters. The and subroutines
       are identical in function, but are case insensitive.  The returned lexicographic difference reflects a conversion to lower-case.

       The subroutine copies string s2 to s1, stopping after the null character has been copied.  The  subroutine  copies  exactly  n  characters,
       truncating s2 or adding null characters to s1 if necessary.  The result will not be null-terminated if the length of s2 is n or more.  Each
       function returns s1.

       The subroutine returns the number of characters in s, not including the terminating null character.

       The subroutine returns a pointer to the first occurrence of s2 (excluding the terminating null character) in s1, or a NULL  pointer  if	s2
       does not occur in s1.  If the length of s2 is zero, returns s1.

       The  ( ) function returns a pointer to the first (last) occurrence of character c in string s, or a NULL pointer is c does not occur in the
       string.	The null character terminating a string is considered to be part of the string.

       The subroutine returns a pointer to the first occurrence in string s1 of any character from string s2, or a NULL pointer  if  no  character
       from s2 exists in s1.

       The ( ) subroutine returns the length of the initial segment of string s1 which consists entirely of characters from (not from) string s2.

       The  subroutine	considers  the string s1 to consist of a sequence of zero or more text tokens separated by spans of one or more characters
       from the separator string s2.  The first call (with pointer s1 specified) returns a pointer to the first character of the first token,  and
       will  have  written  a  null  character	into s1 immediately following the returned token.  The function keeps track of its position in the
       string between separate calls, so that subsequent calls (which must be made with the first argument a NULL pointer) will work  through  the
       string  s1  immediately	following  that token.	In this way, subsequent calls will work through the string s1 until no tokens remain.  The
       separator string s2 may be different from call to call.	When no token remains in s1, a NULL pointer is returned.

       The ( ) subroutine returns a pointer to the first (last) occurrence of character c in string s, or zero if c does not occur in  the string.
       The <string.h> header file is provided for compatibility with System V; both <string.h> and <strings.h> refer to the same file.
       The and subroutines do unsigned character comparisons.

																	 string(3)

Featured Tech Videos