/************************************************************************************
Copyright (C) 2013,2019 MariaDB Corporation AB
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not see <http://www.gnu.org/licenses>
or write to the Free Software Foundation, Inc.,
51 Franklin St., Fifth Floor, Boston, MA 02110, USA
*************************************************************************************/
#include <ma_odbc.h>
extern MARIADB_CHARSET_INFO* DmUnicodeCs;
char *MADB_GetTableName(MADB_Stmt *Stmt)
{
char *TableName= NULL;
unsigned int i= 0;
if (Stmt->TableName && Stmt->TableName[0])
return Stmt->TableName;
if (!mysql_stmt_field_count(Stmt->stmt))
return NULL;
for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)
{
if (Stmt->stmt->fields[i].org_table)
{
if (!TableName)
TableName= Stmt->stmt->fields[i].org_table;
if (strcmp(TableName, Stmt->stmt->fields[i].org_table))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY000, "Couldn't identify unique table name", 0);
return NULL;
}
}
}
if (TableName)
Stmt->TableName= _strdup(TableName);
return TableName;
}
char *MADB_GetCatalogName(MADB_Stmt *Stmt)
{
char *CatalogName= NULL;
unsigned int i= 0;
if (Stmt->CatalogName && Stmt->CatalogName[0])
return Stmt->CatalogName;
if (!mysql_stmt_field_count(Stmt->stmt))
return NULL;
for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)
{
if (Stmt->stmt->fields[i].org_table)
{
if (!CatalogName)
CatalogName= Stmt->stmt->fields[i].db;
if (strcmp(CatalogName, Stmt->stmt->fields[i].db))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY000, "Couldn't identify unique catalog name", 0);
return NULL;
}
}
}
if (CatalogName)
Stmt->CatalogName= _strdup(CatalogName);
return CatalogName;
}
my_bool MADB_DynStrAppendQuoted(MADB_DynString *DynString, char *String)
{
if (MADB_DynstrAppend(DynString, "`") ||
MADB_DynstrAppend(DynString, String) ||
MADB_DynstrAppend(DynString, "`"))
return TRUE;
return FALSE;
}
my_bool MADB_DynStrUpdateSet(MADB_Stmt *Stmt, MADB_DynString *DynString)
{
int i, IgnoredColumns= 0;
MADB_DescRecord *Record;
if (MADB_DynstrAppend(DynString, " SET "))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
// ???? memcpy(&Stmt->Da->Apd->Header, &Stmt->Ard->Header, sizeof(MADB_Header));
for (i=0; i < MADB_STMT_COLUMN_COUNT(Stmt); i++)
{
SQLLEN *IndicatorPtr= NULL;
Record= MADB_DescGetInternalRecord(Stmt->Ard, i, MADB_DESC_READ);
if (Record->IndicatorPtr)
IndicatorPtr= (SQLLEN *)GetBindOffset(Stmt->Ard, Record, Record->IndicatorPtr, Stmt->DaeRowNumber > 1 ? Stmt->DaeRowNumber-1 : 0,
sizeof(SQLLEN)/*Record->OctetLength*/);
if ((IndicatorPtr && *IndicatorPtr == SQL_COLUMN_IGNORE) || !Record->inUse)
{
IgnoredColumns++;
continue;
}
if ((i - IgnoredColumns) && MADB_DynstrAppend(DynString, ","))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
if (MADB_DynStrAppendQuoted(DynString, Stmt->stmt->fields[i].org_name))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
if (MADB_DynstrAppend(DynString, "=?"))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
}
if (IgnoredColumns == mysql_stmt_field_count(Stmt->stmt))
{
MADB_SetError(&Stmt->Error, MADB_ERR_21S02, NULL, 0);
return TRUE;
}
return FALSE;
}
my_bool MADB_DynStrInsertSet(MADB_Stmt *Stmt, MADB_DynString *DynString)
{
MADB_DynString ColVals;
int i, NeedComma= 0;
MADB_DescRecord *Record;
MADB_InitDynamicString(&ColVals, "VALUES (", 32, 32);
if (MADB_DynstrAppend(DynString, " ("))
{
goto dynerror;
return TRUE;
}
/* We use only columns, that have been bound, and are not IGNORED */
for (i= 0; i < MADB_STMT_COLUMN_COUNT(Stmt); i++)
{
Record= MADB_DescGetInternalRecord(Stmt->Ard, i, MADB_DESC_READ);
if (!Record->inUse || MADB_ColumnIgnoredInAllRows(Stmt->Ard, Record) == TRUE)
{
continue;
}
if ((NeedComma) &&
(MADB_DynstrAppend(DynString, ",") || MADB_DynstrAppend(&ColVals, ",")))
goto dynerror;
if (MADB_DynStrAppendQuoted(DynString, Stmt->stmt->fields[i].org_name) ||
MADB_DynstrAppend(&ColVals, "?"))
goto dynerror;
NeedComma= 1;
}
if (MADB_DynstrAppend(DynString, ") " ) ||
MADB_DynstrAppend(&ColVals, ")") ||
MADB_DynstrAppend(DynString, ColVals.str))
goto dynerror;
MADB_DynstrFree(&ColVals);
return FALSE;
dynerror:
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
MADB_DynstrFree(&ColVals);
return TRUE;
}
my_bool MADB_DynStrGetColumns(MADB_Stmt *Stmt, MADB_DynString *DynString)
{
unsigned int i;
if (MADB_DynstrAppend(DynString, " ("))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)
{
if (i && MADB_DynstrAppend(DynString, ", "))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
if (MADB_DynStrAppendQuoted(DynString, Stmt->stmt->fields[i].org_name))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
}
if (MADB_DynstrAppend(DynString, " )"))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
return FALSE;
}
my_bool MADB_DynStrGetWhere(MADB_Stmt *Stmt, MADB_DynString *DynString, char *TableName, my_bool ParameterMarkers)
{
int UniqueCount=0, PrimaryCount= 0;
int i, Flag= 0;
char *Column= NULL, *Escaped= NULL;
SQLLEN StrLength;
unsigned long EscapedLength;
for (i= 0; i < MADB_STMT_COLUMN_COUNT(Stmt); i++)
{
MYSQL_FIELD *field= mysql_fetch_field_direct(FetchMetadata(Stmt), i);
if (field->flags & PRI_KEY_FLAG)
PrimaryCount++;
if (field->flags & UNIQUE_KEY_FLAG)
UniqueCount++;
}
/* We need to use all columns, otherwise it will be difficult to map fields for Positioned Update */
if (PrimaryCount && PrimaryCount != MADB_KeyTypeCount(Stmt->Connection, TableName, PRI_KEY_FLAG))
PrimaryCount= 0;
if (UniqueCount && UniqueCount != MADB_KeyTypeCount(Stmt->Connection, TableName, UNIQUE_KEY_FLAG))
UniqueCount= 0;
/* if no primary or unique key is in the cursor, the cursor must contain all
columns from table in TableName */
if (!PrimaryCount && !UniqueCount)
{
char StmtStr[256];
MADB_Stmt *CountStmt;
int FieldCount= 0;
MA_SQLAllocHandle(SQL_HANDLE_STMT, Stmt->Connection, (SQLHANDLE*)&CountStmt);
_snprintf(StmtStr, 256, "SELECT * FROM `%s` LIMIT 0", TableName);
CountStmt->Methods->ExecDirect(CountStmt, (char *)StmtStr, SQL_NTS);
FieldCount= mysql_stmt_field_count(((MADB_Stmt *)CountStmt)->stmt);
CountStmt->Methods->StmtFree(CountStmt, SQL_DROP);
if (FieldCount != MADB_STMT_COLUMN_COUNT(Stmt))
{
MADB_SetError(&Stmt->Error, MADB_ERR_S1000, "Can't build index for update/delete", 0);
return TRUE;
}
}
if (MADB_DynstrAppend(DynString, " WHERE 1"))
goto memerror;
for (i= 0; i < MADB_STMT_COLUMN_COUNT(Stmt); i++)
{
MYSQL_FIELD *field= mysql_fetch_field_direct(Stmt->metadata, i);
if (field->flags & Flag || !Flag)
{
if (MADB_DynstrAppend(DynString, " AND ") ||
MADB_DynStrAppendQuoted(DynString, field->org_name))
goto memerror;
if (ParameterMarkers)
{
if (MADB_DynstrAppend(DynString, "=?"))
goto memerror;
}
else
{
if (!SQL_SUCCEEDED(Stmt->Methods->GetData(Stmt, i+1, SQL_C_CHAR, NULL, 0, &StrLength, TRUE)))
{
MADB_FREE(Column);
return TRUE;
}
if (StrLength < 0)
{
if (MADB_DynstrAppend(DynString, " IS NULL"))
goto memerror;
}
else
{
Column= MADB_CALLOC(StrLength + 1);
Stmt->Methods->GetData(Stmt,i+1, SQL_C_CHAR, Column, StrLength + 1, &StrLength, TRUE);
Escaped = MADB_CALLOC(2 * StrLength + 1);
EscapedLength= mysql_real_escape_string(Stmt->Connection->mariadb, Escaped, Column, (unsigned long)StrLength);
if (MADB_DynstrAppend(DynString, "= '") ||
MADB_DynstrAppend(DynString, Escaped) ||//, EscapedLength) ||
MADB_DynstrAppend(DynString, "'"))
{
goto memerror;
}
MADB_FREE(Column);
MADB_FREE(Escaped);
}
}
}
}
if (MADB_DynstrAppend(DynString, " LIMIT 1"))
goto memerror;
MADB_FREE(Column);
return FALSE;
memerror:
MADB_FREE(Column);
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
my_bool MADB_DynStrGetValues(MADB_Stmt *Stmt, MADB_DynString *DynString)
{
unsigned int i;
if (MADB_DynstrAppend(DynString, " VALUES("))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)
{
if (MADB_DynstrAppend(DynString, (i) ? ",?" : "?"))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
}
if (MADB_DynstrAppend(DynString, ")"))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
return TRUE;
}
return FALSE;
}
char *MADB_GetInsertStatement(MADB_Stmt *Stmt)
{
char *StmtStr;
size_t Length= 1024;
char *p;
char *TableName;
unsigned int i;
if (!(StmtStr= MADB_CALLOC(1024)))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY013, NULL, 0);
return NULL;
}
if (!(TableName= MADB_GetTableName(Stmt)))
goto error;
p= StmtStr;
p+= _snprintf(StmtStr, 1024, "INSERT INTO `%s` (", TableName);
for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)
{
if (strlen(StmtStr) > Length - NAME_LEN - 4/* comma + 2 ticks + terminating NULL */)
{
Length+= 1024;
if (!(StmtStr= MADB_REALLOC(StmtStr, Length)))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY013, NULL, 0);
goto error;
}
}
p+= _snprintf(p, Length - strlen(StmtStr), "%s`%s`", (i==0) ? "" : ",", Stmt->stmt->fields[i].org_name);
}
p+= _snprintf(p, Length - strlen(StmtStr), ") VALUES (");
if (strlen(StmtStr) > Length - mysql_stmt_field_count(Stmt->stmt)*2 - 1)/* , and ? for each column + (- 1 comma for 1st column + closing ')')
+ terminating NULL */
{
Length= strlen(StmtStr) + mysql_stmt_field_count(Stmt->stmt)*2 + 1;
if (!(StmtStr= MADB_REALLOC(StmtStr, Length)))
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY013, NULL, 0);
goto error;
}
}
for (i=0; i < mysql_stmt_field_count(Stmt->stmt); i++)
{
p+= _snprintf(p, Length - strlen(StmtStr), "%s?", (i==0) ? "" : ",");
}
p+= _snprintf(p, Length - strlen(StmtStr), ")");
return StmtStr;
error:
if (StmtStr)
MADB_FREE(StmtStr);
return NULL;
}
my_bool MADB_ValidateStmt(MADB_QUERY *Query)
{
return Query->QueryType != MADB_QUERY_SET_NAMES;
}
char *MADB_ToLower(const char *src, char *buff, size_t buff_size)
{
size_t i= 0;
if (buff_size > 0)
{
while (*src && i < buff_size)
{
buff[i++]= tolower(*src++);
}
buff[i == buff_size ? i - 1 : i]= '\0';
}
return buff;
}
int InitClientCharset(Client_Charset *cc, const char * name)
{
/* There is no legal charset names longer than 31 chars */
char lowered[32];
cc->cs_info= mariadb_get_charset_by_name(MADB_ToLower(name, lowered, sizeof(lowered)));
if (cc->cs_info == NULL)
{
return 1;
}
cc->CodePage= cc->cs_info->codepage;
return 0;
}
void CopyClientCharset(Client_Charset * Src, Client_Charset * Dst)
{
Dst->CodePage= Src->CodePage;
Dst->cs_info= Src->cs_info;
}
void CloseClientCharset(Client_Charset *cc)
{
}
/* Hmmm... Length in characters is SQLLEN, octet length SQLINTEGER */
SQLLEN MbstrOctetLen(const char *str, SQLLEN *CharLen, MARIADB_CHARSET_INFO *cs)
{
SQLLEN result= 0, inChars= *CharLen;
if (str)
{
if (cs->mb_charlen == NULL)
{
/* Charset uses no more than a byte per char. Result is strlen or umber of chars */
if (*CharLen < 0)
{
result= (SQLLEN)strlen(str);
*CharLen= result;
}
else
{
result= *CharLen;
}
return result;
}
else
{
while (inChars > 0 || (inChars < 0 && *str))
{
result+= cs->mb_charlen(0 + *str);
--inChars;
str+= cs->mb_charlen(*str);
}
}
}
if (*CharLen < 0)
{
*CharLen-= inChars;
}
return result;
}
/* Number of characters in given number of bytes */
SQLLEN MbstrCharLen(const char *str, SQLINTEGER OctetLen, MARIADB_CHARSET_INFO *cs)
{
SQLLEN result= 0;
const char *ptr= str;
unsigned int charlen;
if (str)
{
if (cs->mb_charlen == NULL || cs->char_maxlen == 1)
{
return OctetLen;
}
while (ptr < str + OctetLen)
{
charlen= cs->mb_charlen((unsigned char)*ptr);
if (charlen == 0)
{
/* Dirty hack to avoid dead loop - Has to be the error! */
charlen= 1;
}
/* Skipping thru 0 bytes */
while (charlen > 0 && *ptr == '\0')
{
--charlen;
++ptr;
}
/* Stopping if current character is terminating NULL - charlen == 0 means all bytes of current char was 0 */
if (charlen == 0)
{
return result;
}
/* else we increment ptr for number of left bytes */
ptr+= charlen;
++result;
}
}
return result;
}
/* Length of NT SQLWCHAR string in characters */
SQLINTEGER SqlwcsCharLen(SQLWCHAR *str, SQLLEN octets)
{
SQLINTEGER result= 0;
SQLWCHAR *end= octets != (SQLLEN)-1 ? str + octets/sizeof(SQLWCHAR) : (SQLWCHAR*)octets /*for simplicity - the address to be always bigger */;
if (str)
{
while (str < end && *str)
{
str+= (DmUnicodeCs->mb_charlen(*str))/sizeof(SQLWCHAR);
if (str > end)
{
break;
}
++result;
}
}
return result;
}
/* Length in SQLWCHAR units
@buff_length[in] - size of the str buffer or negative number */
SQLLEN SqlwcsLen(SQLWCHAR *str, SQLLEN buff_length)
{
SQLINTEGER result= 0;
if (str)
{
/* If buff_length is negative - we will never hit 1st condition, otherwise we hit it after last character
of the buffer is processed */
while ((--buff_length) != -1 && *str)
{
++result;
++str;
}
}
return result;
}
/* Length of a string with respect to specified buffer size
@buff_length[in] - size of the str buffer or negative number */
SQLLEN SafeStrlen(SQLCHAR *str, SQLLEN buff_length)
{
SQLINTEGER result= 0;
if (str)
{
/* If buff_length is negative - we will never hit 1st condition, otherwise we hit it after last character
of the buffer is processed */
while ((--buff_length) != -1 && *str)
{
++result;
++str;
}
}
return result;
}