/hphp/runtime/ext/ext_pdo.cpp
C++ | 3181 lines | 2844 code | 224 blank | 113 comment | 368 complexity | 90d855a73dd4ac677e3f5f928184c0dc MD5 | raw file
Possible License(s): LGPL-2.1, BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, MIT, LGPL-2.0, Apache-2.0
- /*
- +----------------------------------------------------------------------+
- | HipHop for PHP |
- +----------------------------------------------------------------------+
- | Copyright (c) 2010-2013 Facebook, Inc. (http://www.facebook.com) |
- | Copyright (c) 1997-2010 The PHP Group |
- +----------------------------------------------------------------------+
- | This source file is subject to version 3.01 of the PHP license, |
- | that is bundled with this package in the file LICENSE, and is |
- | available through the world-wide-web at the following url: |
- | http://www.php.net/license/3_01.txt |
- | If you did not receive a copy of the PHP license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- */
- #include "hphp/runtime/ext/ext_pdo.h"
- #include "hphp/runtime/ext/pdo_driver.h"
- #include "hphp/runtime/ext/pdo_mysql.h"
- #include "hphp/runtime/ext/ext_class.h"
- #include "hphp/runtime/ext/ext_function.h"
- #include "hphp/runtime/ext/ext_stream.h"
- #include "hphp/runtime/ext/ext_string.h"
- #include "hphp/runtime/base/class-info.h"
- #include "hphp/runtime/base/ini-setting.h"
- #include "hphp/runtime/base/string-buffer.h"
- #include "hphp/runtime/base/request-local.h"
- #include "hphp/runtime/base/macros.h"
- #include "hphp/system/systemlib.h"
- #define PDO_HANDLE_DBH_ERR(dbh) \
- if (strcmp(dbh->error_code, PDO_ERR_NONE)) { \
- pdo_handle_error(dbh, nullptr); \
- } \
- #define PDO_HANDLE_STMT_ERR(stmt) \
- if (strcmp(stmt->error_code, PDO_ERR_NONE)) { \
- pdo_handle_error(stmt->dbh, stmt); \
- } \
- namespace HPHP {
- IMPLEMENT_DEFAULT_EXTENSION(PDO);
- ///////////////////////////////////////////////////////////////////////////////
- // PDO constants
- const int64_t q_PDO$$PARAM_BOOL = PDO_PARAM_BOOL;
- const int64_t q_PDO$$PARAM_NULL = PDO_PARAM_NULL;
- const int64_t q_PDO$$PARAM_INT = PDO_PARAM_INT;
- const int64_t q_PDO$$PARAM_STR = PDO_PARAM_STR;
- const int64_t q_PDO$$PARAM_LOB = PDO_PARAM_LOB;
- const int64_t q_PDO$$PARAM_STMT = PDO_PARAM_STMT;
- const int64_t q_PDO$$PARAM_INPUT_OUTPUT = PDO_PARAM_INPUT_OUTPUT;
- const int64_t q_PDO$$PARAM_EVT_ALLOC = PDO_PARAM_EVT_ALLOC;
- const int64_t q_PDO$$PARAM_EVT_FREE = PDO_PARAM_EVT_FREE;
- const int64_t q_PDO$$PARAM_EVT_EXEC_PRE = PDO_PARAM_EVT_EXEC_PRE;
- const int64_t q_PDO$$PARAM_EVT_EXEC_POST = PDO_PARAM_EVT_EXEC_POST;
- const int64_t q_PDO$$PARAM_EVT_FETCH_PRE = PDO_PARAM_EVT_FETCH_PRE;
- const int64_t q_PDO$$PARAM_EVT_FETCH_POST = PDO_PARAM_EVT_FETCH_POST;
- const int64_t q_PDO$$PARAM_EVT_NORMALIZE = PDO_PARAM_EVT_NORMALIZE;
- const int64_t q_PDO$$FETCH_USE_DEFAULT = PDO_FETCH_USE_DEFAULT;
- const int64_t q_PDO$$FETCH_LAZY = PDO_FETCH_LAZY;
- const int64_t q_PDO$$FETCH_ASSOC = PDO_FETCH_ASSOC;
- const int64_t q_PDO$$FETCH_NUM = PDO_FETCH_NUM;
- const int64_t q_PDO$$FETCH_BOTH = PDO_FETCH_BOTH;
- const int64_t q_PDO$$FETCH_OBJ = PDO_FETCH_OBJ;
- const int64_t q_PDO$$FETCH_BOUND = PDO_FETCH_BOUND;
- const int64_t q_PDO$$FETCH_COLUMN = PDO_FETCH_COLUMN;
- const int64_t q_PDO$$FETCH_CLASS = PDO_FETCH_CLASS;
- const int64_t q_PDO$$FETCH_INTO = PDO_FETCH_INTO;
- const int64_t q_PDO$$FETCH_FUNC = PDO_FETCH_FUNC;
- const int64_t q_PDO$$FETCH_GROUP = PDO_FETCH_GROUP;
- const int64_t q_PDO$$FETCH_UNIQUE = PDO_FETCH_UNIQUE;
- const int64_t q_PDO$$FETCH_KEY_PAIR = PDO_FETCH_KEY_PAIR;
- const int64_t q_PDO$$FETCH_CLASSTYPE = PDO_FETCH_CLASSTYPE;
- const int64_t q_PDO$$FETCH_SERIALIZE = PDO_FETCH_SERIALIZE;
- const int64_t q_PDO$$FETCH_PROPS_LATE = PDO_FETCH_PROPS_LATE;
- const int64_t q_PDO$$FETCH_NAMED = PDO_FETCH_NAMED;
- const int64_t q_PDO$$ATTR_AUTOCOMMIT = PDO_ATTR_AUTOCOMMIT;
- const int64_t q_PDO$$ATTR_PREFETCH = PDO_ATTR_PREFETCH;
- const int64_t q_PDO$$ATTR_TIMEOUT = PDO_ATTR_TIMEOUT;
- const int64_t q_PDO$$ATTR_ERRMODE = PDO_ATTR_ERRMODE;
- const int64_t q_PDO$$ATTR_SERVER_VERSION = PDO_ATTR_SERVER_VERSION;
- const int64_t q_PDO$$ATTR_CLIENT_VERSION = PDO_ATTR_CLIENT_VERSION;
- const int64_t q_PDO$$ATTR_SERVER_INFO = PDO_ATTR_SERVER_INFO;
- const int64_t q_PDO$$ATTR_CONNECTION_STATUS = PDO_ATTR_CONNECTION_STATUS;
- const int64_t q_PDO$$ATTR_CASE = PDO_ATTR_CASE;
- const int64_t q_PDO$$ATTR_CURSOR_NAME = PDO_ATTR_CURSOR_NAME;
- const int64_t q_PDO$$ATTR_CURSOR = PDO_ATTR_CURSOR;
- const int64_t q_PDO$$ATTR_ORACLE_NULLS = PDO_ATTR_ORACLE_NULLS;
- const int64_t q_PDO$$ATTR_PERSISTENT = PDO_ATTR_PERSISTENT;
- const int64_t q_PDO$$ATTR_STATEMENT_CLASS = PDO_ATTR_STATEMENT_CLASS;
- const int64_t q_PDO$$ATTR_FETCH_TABLE_NAMES = PDO_ATTR_FETCH_TABLE_NAMES;
- const int64_t q_PDO$$ATTR_FETCH_CATALOG_NAMES = PDO_ATTR_FETCH_CATALOG_NAMES;
- const int64_t q_PDO$$ATTR_DRIVER_NAME = PDO_ATTR_DRIVER_NAME;
- const int64_t q_PDO$$ATTR_STRINGIFY_FETCHES = PDO_ATTR_STRINGIFY_FETCHES;
- const int64_t q_PDO$$ATTR_MAX_COLUMN_LEN = PDO_ATTR_MAX_COLUMN_LEN;
- const int64_t q_PDO$$ATTR_EMULATE_PREPARES = PDO_ATTR_EMULATE_PREPARES;
- const int64_t q_PDO$$ATTR_DEFAULT_FETCH_MODE = PDO_ATTR_DEFAULT_FETCH_MODE;
- const int64_t q_PDO$$ERRMODE_SILENT = PDO_ERRMODE_SILENT;
- const int64_t q_PDO$$ERRMODE_WARNING = PDO_ERRMODE_WARNING;
- const int64_t q_PDO$$ERRMODE_EXCEPTION = PDO_ERRMODE_EXCEPTION;
- const int64_t q_PDO$$CASE_NATURAL = PDO_CASE_NATURAL;
- const int64_t q_PDO$$CASE_LOWER = PDO_CASE_LOWER;
- const int64_t q_PDO$$CASE_UPPER = PDO_CASE_UPPER;
- const int64_t q_PDO$$NULL_NATURAL = PDO_NULL_NATURAL;
- const int64_t q_PDO$$NULL_EMPTY_STRING = PDO_NULL_EMPTY_STRING;
- const int64_t q_PDO$$NULL_TO_STRING = PDO_NULL_TO_STRING;
- const StaticString q_PDO$$ERR_NONE(LITSTR_INIT(PDO_ERR_NONE));
- const int64_t q_PDO$$FETCH_ORI_NEXT = PDO_FETCH_ORI_NEXT;
- const int64_t q_PDO$$FETCH_ORI_PRIOR = PDO_FETCH_ORI_PRIOR;
- const int64_t q_PDO$$FETCH_ORI_FIRST = PDO_FETCH_ORI_FIRST;
- const int64_t q_PDO$$FETCH_ORI_LAST = PDO_FETCH_ORI_LAST;
- const int64_t q_PDO$$FETCH_ORI_ABS = PDO_FETCH_ORI_ABS;
- const int64_t q_PDO$$FETCH_ORI_REL = PDO_FETCH_ORI_REL;
- const int64_t q_PDO$$CURSOR_FWDONLY = PDO_CURSOR_FWDONLY;
- const int64_t q_PDO$$CURSOR_SCROLL = PDO_CURSOR_SCROLL;
- ///////////////////////////////////////////////////////////////////////////////
- const int64_t q_PDO$$MYSQL_ATTR_USE_BUFFERED_QUERY =
- PDO_MYSQL_ATTR_USE_BUFFERED_QUERY;
- const int64_t q_PDO$$MYSQL_ATTR_LOCAL_INFILE = PDO_MYSQL_ATTR_LOCAL_INFILE;
- const int64_t q_PDO$$MYSQL_ATTR_MAX_BUFFER_SIZE =
- PDO_MYSQL_ATTR_MAX_BUFFER_SIZE;
- const int64_t q_PDO$$MYSQL_ATTR_INIT_COMMAND = PDO_MYSQL_ATTR_INIT_COMMAND;
- const int64_t q_PDO$$MYSQL_ATTR_READ_DEFAULT_FILE =
- PDO_MYSQL_ATTR_READ_DEFAULT_FILE;
- const int64_t q_PDO$$MYSQL_ATTR_READ_DEFAULT_GROUP =
- PDO_MYSQL_ATTR_READ_DEFAULT_GROUP;
- const int64_t q_PDO$$MYSQL_ATTR_COMPRESS = PDO_MYSQL_ATTR_COMPRESS;
- const int64_t q_PDO$$MYSQL_ATTR_DIRECT_QUERY = PDO_MYSQL_ATTR_DIRECT_QUERY;
- const int64_t q_PDO$$MYSQL_ATTR_FOUND_ROWS = PDO_MYSQL_ATTR_FOUND_ROWS;
- const int64_t q_PDO$$MYSQL_ATTR_IGNORE_SPACE = PDO_MYSQL_ATTR_IGNORE_SPACE;
- ///////////////////////////////////////////////////////////////////////////////
- // extension functions
- Array f_pdo_drivers() {
- Array ret = Array::Create();
- const PDODriverMap &drivers = PDODriver::GetDrivers();
- for (PDODriverMap::const_iterator iter = drivers.begin();
- iter != drivers.end(); ++iter) {
- ret.append(iter->second->getName());
- }
- return ret;
- }
- ///////////////////////////////////////////////////////////////////////////////
- // error handling
- struct pdo_sqlstate_info {
- const char *state;
- const char *desc;
- };
- static const struct pdo_sqlstate_info err_initializer[] = {
- { "00000", "No error" },
- { "01000", "Warning" },
- { "01001", "Cursor operation conflict" },
- { "01002", "Disconnect error" },
- { "01003", "NULL value eliminated in set function" },
- { "01004", "String data, right truncated" },
- { "01006", "Privilege not revoked" },
- { "01007", "Privilege not granted" },
- { "01008", "Implicit zero bit padding" },
- { "0100C", "Dynamic result sets returned" },
- { "01P01", "Deprecated feature" },
- { "01S00", "Invalid connection string attribute" },
- { "01S01", "Error in row" },
- { "01S02", "Option value changed" },
- { "01S06",
- "Attempt to fetch before the result set returned the first rowset" },
- { "01S07", "Fractional truncation" },
- { "01S08", "Error saving File DSN" },
- { "01S09", "Invalid keyword" },
- { "02000", "No data" },
- { "02001", "No additional dynamic result sets returned" },
- { "03000", "Sql statement not yet complete" },
- { "07002", "COUNT field incorrect" },
- { "07005", "Prepared statement not a cursor-specification" },
- { "07006", "Restricted data type attribute violation" },
- { "07009", "Invalid descriptor index" },
- { "07S01", "Invalid use of default parameter" },
- { "08000", "Connection exception" },
- { "08001", "Client unable to establish connection" },
- { "08002", "Connection name in use" },
- { "08003", "Connection does not exist" },
- { "08004", "Server rejected the connection" },
- { "08006", "Connection failure" },
- { "08007", "Connection failure during transaction" },
- { "08S01", "Communication link failure" },
- { "09000", "Triggered action exception" },
- { "0A000", "Feature not supported" },
- { "0B000", "Invalid transaction initiation" },
- { "0F000", "Locator exception" },
- { "0F001", "Invalid locator specification" },
- { "0L000", "Invalid grantor" },
- { "0LP01", "Invalid grant operation" },
- { "0P000", "Invalid role specification" },
- { "21000", "Cardinality violation" },
- { "21S01", "Insert value list does not match column list" },
- { "21S02", "Degree of derived table does not match column list" },
- { "22000", "Data exception" },
- { "22001", "String data, right truncated" },
- { "22002", "Indicator variable required but not supplied" },
- { "22003", "Numeric value out of range" },
- { "22004", "Null value not allowed" },
- { "22005", "Error in assignment" },
- { "22007", "Invalid datetime format" },
- { "22008", "Datetime field overflow" },
- { "22009", "Invalid time zone displacement value" },
- { "2200B", "Escape character conflict" },
- { "2200C", "Invalid use of escape character" },
- { "2200D", "Invalid escape octet" },
- { "2200F", "Zero length character string" },
- { "2200G", "Most specific type mismatch" },
- { "22010", "Invalid indicator parameter value" },
- { "22011", "Substring error" },
- { "22012", "Division by zero" },
- { "22015", "Interval field overflow" },
- { "22018", "Invalid character value for cast specification" },
- { "22019", "Invalid escape character" },
- { "2201B", "Invalid regular expression" },
- { "2201E", "Invalid argument for logarithm" },
- { "2201F", "Invalid argument for power function" },
- { "2201G", "Invalid argument for width bucket function" },
- { "22020", "Invalid limit value" },
- { "22021", "Character not in repertoire" },
- { "22022", "Indicator overflow" },
- { "22023", "Invalid parameter value" },
- { "22024", "Unterminated c string" },
- { "22025", "Invalid escape sequence" },
- { "22026", "String data, length mismatch" },
- { "22027", "Trim error" },
- { "2202E", "Array subscript error" },
- { "22P01", "Floating point exception" },
- { "22P02", "Invalid text representation" },
- { "22P03", "Invalid binary representation" },
- { "22P04", "Bad copy file format" },
- { "22P05", "Untranslatable character" },
- { "23000", "Integrity constraint violation" },
- { "23001", "Restrict violation" },
- { "23502", "Not null violation" },
- { "23503", "Foreign key violation" },
- { "23505", "Unique violation" },
- { "23514", "Check violation" },
- { "24000", "Invalid cursor state" },
- { "25000", "Invalid transaction state" },
- { "25001", "Active sql transaction" },
- { "25002", "Branch transaction already active" },
- { "25003", "Inappropriate access mode for branch transaction" },
- { "25004", "Inappropriate isolation level for branch transaction" },
- { "25005", "No active sql transaction for branch transaction" },
- { "25006", "Read only sql transaction" },
- { "25007", "Schema and data statement mixing not supported" },
- { "25008", "Held cursor requires same isolation level" },
- { "25P01", "No active sql transaction" },
- { "25P02", "In failed sql transaction" },
- { "25S01", "Transaction state" },
- { "25S02", "Transaction is still active" },
- { "25S03", "Transaction is rolled back" },
- { "26000", "Invalid sql statement name" },
- { "27000", "Triggered data change violation" },
- { "28000", "Invalid authorization specification" },
- { "2B000", "Dependent privilege descriptors still exist" },
- { "2BP01", "Dependent objects still exist" },
- { "2D000", "Invalid transaction termination" },
- { "2F000", "Sql routine exception" },
- { "2F002", "Modifying sql data not permitted" },
- { "2F003", "Prohibited sql statement attempted" },
- { "2F004", "Reading sql data not permitted" },
- { "2F005", "Function executed no return statement" },
- { "34000", "Invalid cursor name" },
- { "38000", "External routine exception" },
- { "38001", "Containing sql not permitted" },
- { "38002", "Modifying sql data not permitted" },
- { "38003", "Prohibited sql statement attempted" },
- { "38004", "Reading sql data not permitted" },
- { "39000", "External routine invocation exception" },
- { "39001", "Invalid sqlstate returned" },
- { "39004", "Null value not allowed" },
- { "39P01", "Trigger protocol violated" },
- { "39P02", "Srf protocol violated" },
- { "3B000", "Savepoint exception" },
- { "3B001", "Invalid savepoint specification" },
- { "3C000", "Duplicate cursor name" },
- { "3D000", "Invalid catalog name" },
- { "3F000", "Invalid schema name" },
- { "40000", "Transaction rollback" },
- { "40001", "Serialization failure" },
- { "40002", "Transaction integrity constraint violation" },
- { "40003", "Statement completion unknown" },
- { "40P01", "Deadlock detected" },
- { "42000", "Syntax error or access violation" },
- { "42501", "Insufficient privilege" },
- { "42601", "Syntax error" },
- { "42602", "Invalid name" },
- { "42611", "Invalid column definition" },
- { "42622", "Name too long" },
- { "42701", "Duplicate column" },
- { "42702", "Ambiguous column" },
- { "42703", "Undefined column" },
- { "42704", "Undefined object" },
- { "42710", "Duplicate object" },
- { "42712", "Duplicate alias" },
- { "42723", "Duplicate function" },
- { "42725", "Ambiguous function" },
- { "42803", "Grouping error" },
- { "42804", "Datatype mismatch" },
- { "42809", "Wrong object type" },
- { "42830", "Invalid foreign key" },
- { "42846", "Cannot coerce" },
- { "42883", "Undefined function" },
- { "42939", "Reserved name" },
- { "42P01", "Undefined table" },
- { "42P02", "Undefined parameter" },
- { "42P03", "Duplicate cursor" },
- { "42P04", "Duplicate database" },
- { "42P05", "Duplicate prepared statement" },
- { "42P06", "Duplicate schema" },
- { "42P07", "Duplicate table" },
- { "42P08", "Ambiguous parameter" },
- { "42P09", "Ambiguous alias" },
- { "42P10", "Invalid column reference" },
- { "42P11", "Invalid cursor definition" },
- { "42P12", "Invalid database definition" },
- { "42P13", "Invalid function definition" },
- { "42P14", "Invalid prepared statement definition" },
- { "42P15", "Invalid schema definition" },
- { "42P16", "Invalid table definition" },
- { "42P17", "Invalid object definition" },
- { "42P18", "Indeterminate datatype" },
- { "42S01", "Base table or view already exists" },
- { "42S02", "Base table or view not found" },
- { "42S11", "Index already exists" },
- { "42S12", "Index not found" },
- { "42S21", "Column already exists" },
- { "42S22", "Column not found" },
- { "44000", "WITH CHECK OPTION violation" },
- { "53000", "Insufficient resources" },
- { "53100", "Disk full" },
- { "53200", "Out of memory" },
- { "53300", "Too many connections" },
- { "54000", "Program limit exceeded" },
- { "54001", "Statement too complex" },
- { "54011", "Too many columns" },
- { "54023", "Too many arguments" },
- { "55000", "Object not in prerequisite state" },
- { "55006", "Object in use" },
- { "55P02", "Cant change runtime param" },
- { "55P03", "Lock not available" },
- { "57000", "Operator intervention" },
- { "57014", "Query canceled" },
- { "57P01", "Admin shutdown" },
- { "57P02", "Crash shutdown" },
- { "57P03", "Cannot connect now" },
- { "58030", "Io error" },
- { "58P01", "Undefined file" },
- { "58P02", "Duplicate file" },
- { "F0000", "Config file error" },
- { "F0001", "Lock file exists" },
- { "HY000", "General error" },
- { "HY001", "Memory allocation error" },
- { "HY003", "Invalid application buffer type" },
- { "HY004", "Invalid SQL data type" },
- { "HY007", "Associated statement is not prepared" },
- { "HY008", "Operation canceled" },
- { "HY009", "Invalid use of null pointer" },
- { "HY010", "Function sequence error" },
- { "HY011", "Attribute cannot be set now" },
- { "HY012", "Invalid transaction operation code" },
- { "HY013", "Memory management error" },
- { "HY014", "Limit on the number of handles exceeded" },
- { "HY015", "No cursor name available" },
- { "HY016", "Cannot modify an implementation row descriptor" },
- { "HY017", "Invalid use of an automatically allocated descriptor handle" },
- { "HY018", "Server declined cancel request" },
- { "HY019", "Non-character and non-binary data sent in pieces" },
- { "HY020", "Attempt to concatenate a null value" },
- { "HY021", "Inconsistent descriptor information" },
- { "HY024", "Invalid attribute value" },
- { "HY090", "Invalid string or buffer length" },
- { "HY091", "Invalid descriptor field identifier" },
- { "HY092", "Invalid attribute/option identifier" },
- { "HY093", "Invalid parameter number" },
- { "HY095", "Function type out of range" },
- { "HY096", "Invalid information type" },
- { "HY097", "Column type out of range" },
- { "HY098", "Scope type out of range" },
- { "HY099", "Nullable type out of range" },
- { "HY100", "Uniqueness option type out of range" },
- { "HY101", "Accuracy option type out of range" },
- { "HY103", "Invalid retrieval code" },
- { "HY104", "Invalid precision or scale value" },
- { "HY105", "Invalid parameter type" },
- { "HY106", "Fetch type out of range" },
- { "HY107", "Row value out of range" },
- { "HY109", "Invalid cursor position" },
- { "HY110", "Invalid driver completion" },
- { "HY111", "Invalid bookmark value" },
- { "HYC00", "Optional feature not implemented" },
- { "HYT00", "Timeout expired" },
- { "HYT01", "Connection timeout expired" },
- { "IM001", "Driver does not support this function" },
- { "IM002", "Data source name not found and no default driver specified" },
- { "IM003", "Specified driver could not be loaded" },
- { "IM004", "Driver's SQLAllocHandle on SQL_HANDLE_ENV failed" },
- { "IM005", "Driver's SQLAllocHandle on SQL_HANDLE_DBC failed" },
- { "IM006", "Driver's SQLSetConnectAttr failed" },
- { "IM007", "No data source or driver specified; dialog prohibited" },
- { "IM008", "Dialog failed" },
- { "IM009", "Unable to load translation DLL" },
- { "IM010", "Data source name too long" },
- { "IM011", "Driver name too long" },
- { "IM012", "DRIVER keyword syntax error" },
- { "IM013", "Trace file error" },
- { "IM014", "Invalid name of File DSN" },
- { "IM015", "Corrupt file data source" },
- { "P0000", "Plpgsql error" },
- { "P0001", "Raise exception" },
- { "XX000", "Internal error" },
- { "XX001", "Data corrupted" },
- { "XX002", "Index corrupted" }
- };
- class PDOErrorHash : private hphp_const_char_map<const char *> {
- public:
- PDOErrorHash() {
- for (unsigned int i = 0;
- i < sizeof(err_initializer)/sizeof(err_initializer[0]); i++) {
- const struct pdo_sqlstate_info *info = &err_initializer[i];
- (*this)[info->state] = info->desc;
- }
- }
- const char *description(const char *state) {
- const_iterator iter = find(state);
- if (iter != end()) {
- return iter->second;
- }
- return "<<Unknown error>>";
- }
- };
- static PDOErrorHash s_err_hash;
- const StaticString
- s_code("code"),
- s_message("message"),
- s_errorInfo("errorInfo"),
- s_PDOException("PDOException");
- void throw_pdo_exception(CVarRef code, CVarRef info, const char *fmt, ...) {
- ObjectData *obj = SystemLib::AllocPDOExceptionObject();
- obj->o_set(s_code, code, s_PDOException);
- va_list ap;
- va_start(ap, fmt);
- string msg;
- Util::string_vsnprintf(msg, fmt, ap);
- obj->o_set(s_message, String(msg), s_PDOException);
- va_end(ap);
- if (!info.isNull()) {
- obj->o_set(s_errorInfo, info, s_PDOException);
- }
- throw Object(obj);
- }
- void pdo_raise_impl_error(sp_PDOConnection dbh, sp_PDOStatement stmt,
- const char *sqlstate, const char *supp) {
- PDOErrorType *pdo_err = &dbh->error_code;
- if (stmt.get()) {
- pdo_err = &stmt->error_code;
- }
- strcpy(*pdo_err, sqlstate);
- const char *msg = s_err_hash.description(sqlstate);
- string err = "SQLSTATE["; err += sqlstate; err += "]: "; err += msg;
- if (supp) {
- err += ": "; err += supp;
- }
- if (dbh->error_mode != PDO_ERRMODE_EXCEPTION) {
- raise_warning("%s", err.c_str());
- } else {
- Array info;
- info.append(String(*pdo_err, CopyString));
- info.append(0LL);
- throw_pdo_exception(String(sqlstate, CopyString), info, "%s", err.c_str());
- }
- }
- static void pdo_handle_error(sp_PDOConnection dbh, sp_PDOStatement stmt) {
- if (dbh->error_mode == PDO_ERRMODE_SILENT) {
- return;
- }
- PDOErrorType *pdo_err = &dbh->error_code;
- if (stmt.get()) {
- pdo_err = &stmt->error_code;
- }
- /* hash sqlstate to error messages */
- const char *msg = s_err_hash.description(*pdo_err);
- int64_t native_code = 0;
- String supp;
- Array info;
- if (dbh->support(PDOConnection::MethodFetchErr)) {
- info = Array::Create();
- info.append(String(*pdo_err, CopyString));
- if (dbh->fetchErr(stmt.get(), info)) {
- if (info.exists(1)) {
- native_code = info[1].toInt64();
- }
- if (info.exists(2)) {
- supp = info[2].toString();
- }
- }
- }
- string err = "SQLSTATE["; err += *pdo_err; err += "]: "; err += msg;
- if (!supp.empty()) {
- err += ": "; err += String(native_code).data();
- err += " "; err += supp.data();
- }
- if (dbh->error_mode != PDO_ERRMODE_EXCEPTION) {
- raise_warning("%s", err.c_str());
- } else {
- throw_pdo_exception(String(*pdo_err, CopyString), info, "%s", err.c_str());
- }
- }
- ///////////////////////////////////////////////////////////////////////////////
- // helpers for PDO class
- static inline int64_t pdo_attr_lval(CArrRef options, PDOAttributeType name,
- int64_t defval) {
- if (options.exists(name)) {
- return options[name].toInt64();
- }
- return defval;
- }
- static inline String pdo_attr_strval(CArrRef options, PDOAttributeType name,
- const String& defval) {
- if (options.exists(name)) {
- return options[name].toString();
- }
- return defval;
- }
- static Object pdo_stmt_instantiate(sp_PDOConnection dbh, const String& clsname,
- CVarRef ctor_args) {
- String name = clsname;
- if (name.empty()) {
- name = "PDOStatement";
- }
- if (!ctor_args.isNull() && !ctor_args.isArray()) {
- pdo_raise_impl_error(dbh, nullptr, "HY000",
- "constructor arguments must be passed as an array");
- return Object();
- }
- Class* cls = Unit::loadClass(name.get());
- if (!cls) {
- return Object();
- }
- return ObjectData::newInstance(cls);
- }
- static void pdo_stmt_construct(sp_PDOStatement stmt, Object object,
- const String& clsname, CVarRef ctor_args) {
- if (clsname.empty()) {
- return;
- }
- Class* cls = Unit::loadClass(clsname.get());
- if (!cls) {
- return;
- }
- object->o_set("queryString", stmt->query_string);
- TypedValue ret;
- ObjectData* inst = object.get();
- g_vmContext->invokeFunc(&ret, cls->getCtor(), ctor_args.toArray(), inst);
- tvRefcountedDecRef(&ret);
- }
- static bool valid_statement_class(sp_PDOConnection dbh, CVarRef opt,
- String &clsname, Variant &ctor_args) {
- if (!opt.isArray() || !opt.toArray().exists(0) || !opt[0].isString() ||
- !f_class_exists(opt[0].toString())) {
- pdo_raise_impl_error
- (dbh, nullptr, "HY000",
- "PDO::ATTR_STATEMENT_CLASS requires format array(classname, "
- "array(ctor_args)); the classname must be a string specifying "
- "an existing class");
- PDO_HANDLE_DBH_ERR(dbh);
- return false;
- }
- clsname = opt[0].toString();
- if (!f_is_subclass_of(clsname, "PDOStatement")) {
- pdo_raise_impl_error
- (dbh, nullptr, "HY000",
- "user-supplied statement class must be derived from PDOStatement");
- PDO_HANDLE_DBH_ERR(dbh);
- return false;
- }
- HPHP::Class* cls = HPHP::Unit::loadClass(clsname.get());
- if (cls) {
- const HPHP::Func* method = cls->getDeclaredCtor();
- if (method && method->isPublic()) {
- pdo_raise_impl_error
- (dbh, nullptr, "HY000",
- "user-supplied statement class cannot have a public constructor");
- PDO_HANDLE_DBH_ERR(dbh);
- return false;
- }
- }
- if (opt.toArray().exists(1)) {
- Variant item = opt[1];
- if (!item.isArray()) {
- pdo_raise_impl_error
- (dbh, nullptr, "HY000",
- "PDO::ATTR_STATEMENT_CLASS requires format array(classname, "
- "ctor_args); ctor_args must be an array");
- PDO_HANDLE_DBH_ERR(dbh);
- return false;
- }
- ctor_args = item;
- }
- return true;
- }
- static bool pdo_stmt_describe_columns(sp_PDOStatement stmt) {
- for (int col = 0; col < stmt->column_count; col++) {
- if (!stmt->describer(col)) {
- return false;
- }
- String &name = stmt->columns[col].toResource().getTyped<PDOColumn>()->name;
- /* if we are applying case conversions on column names, do so now */
- if (stmt->dbh->native_case != stmt->dbh->desired_case &&
- stmt->dbh->desired_case != PDO_CASE_NATURAL) {
- switch (stmt->dbh->desired_case) {
- case PDO_CASE_UPPER:
- name = f_strtoupper(name);
- break;
- case PDO_CASE_LOWER:
- name = f_strtolower(name);
- break;
- default:;
- }
- }
- if (stmt->bound_columns.exists(name)) {
- PDOBoundParam *param =
- stmt->bound_columns[name].toResource().getTyped<PDOBoundParam>();
- param->paramno = col;
- }
- }
- return true;
- }
- static bool pdo_stmt_verify_mode(sp_PDOStatement stmt, int64_t mode,
- bool fetch_all) {
- int flags = mode & PDO_FETCH_FLAGS;
- mode = mode & ~PDO_FETCH_FLAGS;
- if (mode < 0 || mode > PDO_FETCH__MAX) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode");
- return false;
- }
- if (mode == PDO_FETCH_USE_DEFAULT) {
- flags = stmt->default_fetch_type & PDO_FETCH_FLAGS;
- mode = stmt->default_fetch_type & ~PDO_FETCH_FLAGS;
- }
- switch (mode) {
- case PDO_FETCH_FUNC:
- if (!fetch_all) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "PDO::FETCH_FUNC is only allowed in "
- "PDOStatement::fetchAll()");
- return false;
- }
- return true;
- case PDO_FETCH_LAZY:
- if (fetch_all) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "PDO::FETCH_LAZY can't be used with "
- "PDOStatement::fetchAll()");
- return false;
- }
- default:
- if ((flags & PDO_FETCH_SERIALIZE) == PDO_FETCH_SERIALIZE) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "PDO::FETCH_SERIALIZE can only be used "
- "together with PDO::FETCH_CLASS");
- return false;
- }
- if ((flags & PDO_FETCH_CLASSTYPE) == PDO_FETCH_CLASSTYPE) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "PDO::FETCH_CLASSTYPE can only be used "
- "together with PDO::FETCH_CLASS");
- return false;
- }
- if (mode >= PDO_FETCH__MAX) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode");
- return false;
- }
- /* no break; */
- case PDO_FETCH_CLASS:
- break;
- }
- return true;
- }
- static bool do_fetch_class_prepare(sp_PDOStatement stmt) {
- String clsname = stmt->fetch.clsname;
- if (clsname.empty()) {
- stmt->fetch.clsname = "stdclass";
- }
- stmt->fetch.constructor = empty_string; //NULL;
- HPHP::Class* cls = HPHP::Unit::loadClass(clsname.get());
- if (cls) {
- const HPHP::Func* method = cls->getDeclaredCtor();
- if (method) {
- stmt->fetch.constructor = method->nameRef();
- return true;
- }
- }
- if (!stmt->fetch.ctor_args.isNull()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "user-supplied class does not have a constructor, "
- "use NULL for the ctor_params parameter, or simply "
- "omit it");
- return false;
- }
- return true; /* no ctor no args is also ok */
- }
- static bool pdo_stmt_set_fetch_mode(sp_PDOStatement stmt, int _argc, int64_t mode,
- CArrRef _argv) {
- _argc = _argv.size() + 1;
- if (stmt->default_fetch_type == PDO_FETCH_INTO) {
- stmt->fetch.into.reset();
- }
- stmt->default_fetch_type = PDO_FETCH_BOTH;
- if (!pdo_stmt_verify_mode(stmt, mode, false)) {
- strcpy(stmt->error_code, PDO_ERR_NONE);
- return false;
- }
- int flags = mode & PDO_FETCH_FLAGS;
- bool retval = false;
- switch (mode & ~PDO_FETCH_FLAGS) {
- case PDO_FETCH_USE_DEFAULT:
- case PDO_FETCH_LAZY:
- case PDO_FETCH_ASSOC:
- case PDO_FETCH_NUM:
- case PDO_FETCH_BOTH:
- case PDO_FETCH_OBJ:
- case PDO_FETCH_BOUND:
- case PDO_FETCH_NAMED:
- case PDO_FETCH_KEY_PAIR:
- if (_argc != 1) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "fetch mode doesn't allow any extra arguments");
- } else {
- retval = true;
- }
- break;
- case PDO_FETCH_COLUMN:
- if (_argc != 2) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "fetch mode requires the colno argument");
- } else if (!_argv[0].isInteger()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "colno must be an integer");
- } else {
- stmt->fetch.column = _argv[0].toInt64();
- retval = true;
- }
- break;
- case PDO_FETCH_CLASS:
- /* Gets its class name from 1st column */
- if ((flags & PDO_FETCH_CLASSTYPE) == PDO_FETCH_CLASSTYPE) {
- if (_argc != 1) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "fetch mode doesn't allow any extra arguments");
- } else {
- stmt->fetch.clsname.clear();
- retval = true;
- }
- } else {
- if (_argc < 2) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "fetch mode requires the classname argument");
- } else if (_argc > 3) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "too many arguments");
- } else if (!_argv[0].isString()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "classname must be a string");
- } else {
- retval = f_class_exists(_argv[0].toString());
- if (retval) {
- stmt->fetch.clsname = _argv[0].toString();
- }
- }
- }
- if (retval) {
- stmt->fetch.ctor_args.reset();
- if (_argc == 3) {
- if (!_argv[1].isNull() && !_argv[1].isArray()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "ctor_args must be either NULL or an array");
- retval = false;
- } else {
- stmt->fetch.ctor_args = _argv[1];
- }
- }
- if (retval) {
- do_fetch_class_prepare(stmt);
- }
- }
- break;
- case PDO_FETCH_INTO:
- if (_argc != 2) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "fetch mode requires the object parameter");
- } else if (!_argv[0].isObject()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "object must be an object");
- } else {
- retval = true;
- }
- if (retval) {
- stmt->fetch.into = _argv[0];
- }
- break;
- default:
- pdo_raise_impl_error(stmt->dbh, stmt, "22003",
- "Invalid fetch mode specified");
- }
- if (retval) {
- stmt->default_fetch_type = (PDOFetchType)mode;
- }
- /*
- * PDO error (if any) has already been raised at this point.
- *
- * The error_code is cleared, otherwise the caller will read the
- * last error message from the driver.
- *
- */
- strcpy(stmt->error_code, PDO_ERR_NONE);
- return retval;
- }
- ///////////////////////////////////////////////////////////////////////////////
- class PDORequestData : public RequestEventHandler {
- public:
- virtual void requestInit() {
- }
- virtual void requestShutdown() {
- for (std::set<PDOConnection*>::iterator iter =
- m_persistent_connections.begin();
- iter != m_persistent_connections.end(); ++iter) {
- PDOConnection *conn = *iter;
- if (!conn) {
- // Dead handle in the set
- continue;
- }
- if (conn->support(PDOConnection::MethodCheckLiveness) &&
- !conn->checkLiveness()) {
- // Dead connection in the handle
- continue;
- }
- // All seems right, save it
- conn->persistentSave();
- }
- }
- public:
- std::set<PDOConnection*> m_persistent_connections;
- };
- IMPLEMENT_STATIC_REQUEST_LOCAL(PDORequestData, s_pdo_request_data);
- ///////////////////////////////////////////////////////////////////////////////
- // PDO
- c_PDO::c_PDO(Class* cb) : ExtObjectData(cb) {
- }
- c_PDO::~c_PDO() {
- }
- void c_PDO::sweep() {
- // PDOConnection is not sweepable, so clean it up manually.
- static_assert(!std::is_base_of<Sweepable, PDOConnection>::value,
- "Remove the call to reset() below.");
- m_dbh.reset();
- }
- void c_PDO::t___construct(const String& dsn, const String& username /* = null_string */,
- const String& password /* = null_string */,
- CArrRef options /* = null_array */) {
- String data_source = dsn;
- /* parse the data source name */
- const char *colon = strchr(data_source.data(), ':');
- if (!colon) {
- /* let's see if this string has a matching dsn in the php.ini */
- String name = "pdo.dsn."; name += data_source;
- String ini_dsn;
- if (!IniSetting::Get(name, ini_dsn)) {
- throw_pdo_exception(uninit_null(), uninit_null(), "invalid data source name");
- }
- data_source = ini_dsn;
- colon = strchr(data_source.data(), ':');
- if (!colon) {
- throw_pdo_exception(uninit_null(), uninit_null(), "invalid data source name (via INI: %s)",
- ini_dsn.data());
- }
- }
- if (!strncmp(data_source.data(), "uri:", 4)) {
- /* the specified URI holds connection details */
- Variant stream = File::Open(data_source.substr(4), "rb");
- if (same(stream, false)) {
- throw_pdo_exception(uninit_null(), uninit_null(), "invalid data source URI");
- }
- data_source = stream.toResource().getTyped<File>()->readLine(1024);
- colon = strchr(data_source.data(), ':');
- if (!colon) {
- throw_pdo_exception(uninit_null(), uninit_null(), "invalid data source name (via URI)");
- }
- }
- const PDODriverMap &drivers = PDODriver::GetDrivers();
- String name = data_source.substr(0, colon - data_source.data());
- PDODriverMap::const_iterator iter = drivers.find(name.data());
- if (iter == drivers.end()) {
- /* NB: don't want to include the data_source in the error message as
- * it might contain a password */
- throw_pdo_exception(uninit_null(), uninit_null(), "could not find driver");
- }
- PDODriver *driver = iter->second;
- /* is this supposed to be a persistent connection ? */
- bool is_persistent = false;
- bool call_factory = true;
- String shashkey;
- if (!options.empty()) {
- StringBuffer hashkey;
- if (options.exists(PDO_ATTR_PERSISTENT)) {
- Variant v = options[PDO_ATTR_PERSISTENT];
- String sv = v.toString();
- if (v.isString() && !sv.isNumeric() && !sv.empty()) {
- /* user specified key */
- hashkey.printf("PDO:DBH:DSN=%s:%s:%s:%s",
- data_source.data(), username.data(),
- password.data(), sv.data());
- is_persistent = true;
- } else {
- is_persistent = v.toInt64();
- hashkey.printf("PDO:DBH:DSN=%s:%s:%s",
- data_source.data(), username.data(),
- password.data());
- }
- }
- if (is_persistent) {
- shashkey = hashkey.detach();
- /* let's see if we have one cached.... */
- m_dbh = dynamic_cast<PDOConnection*>
- (g_persistentObjects->get(PDOConnection::PersistentKey,
- shashkey.data()));
- if (m_dbh.get()) {
- m_dbh->persistentRestore();
- /* is the connection still alive ? */
- if (m_dbh->support(PDOConnection::MethodCheckLiveness) &&
- !m_dbh->checkLiveness()) {
- /* nope... need to kill it */
- s_pdo_request_data->m_persistent_connections.erase(m_dbh.get());
- m_dbh = nullptr;
- } else {
- /* Yep, use it and mark it for saving at rshutdown */
- s_pdo_request_data->m_persistent_connections.insert(m_dbh.get());
- }
- }
- if (m_dbh.get()) {
- call_factory = false;
- } else {
- /* need a brand new pdbh */
- m_dbh = driver->createConnection(colon+1, username, password, options);
- if (m_dbh.get() == nullptr) {
- throw_pdo_exception(uninit_null(), uninit_null(), "unable to create a connection");
- }
- m_dbh->persistent_id = string(shashkey.data(), shashkey.size());
- }
- }
- }
- if (!m_dbh.get()) {
- m_dbh = driver->createConnection(colon+1, username, password, options);
- if (m_dbh.get() == nullptr) {
- throw_pdo_exception(uninit_null(), uninit_null(), "unable to create a connection");
- }
- }
- if (call_factory) {
- m_dbh->default_fetch_type = PDO_FETCH_BOTH;
- }
- m_dbh->auto_commit = pdo_attr_lval(options, PDO_ATTR_AUTOCOMMIT, 1);
- if (!call_factory) {
- /* we got a persistent guy from our cache */
- for (ArrayIter iter(options); iter; ++iter) {
- t_setattribute(iter.first().toInt64(), iter.second());
- }
- } else if (m_dbh.get()) {
- if (is_persistent) {
- assert(!shashkey.empty());
- g_persistentObjects->set(PDOConnection::PersistentKey, shashkey.data(),
- m_dbh.get());
- s_pdo_request_data->m_persistent_connections.insert(m_dbh.get());
- }
- m_dbh->driver = driver;
- for (ArrayIter iter(options); iter; ++iter) {
- t_setattribute(iter.first().toInt64(), iter.second());
- }
- }
- }
- Variant c_PDO::t_prepare(const String& statement,
- CArrRef options /* = null_array */) {
- assert(m_dbh->driver);
- strcpy(m_dbh->error_code, PDO_ERR_NONE);
- m_dbh->query_stmt = NULL;
- String clsname;
- Variant ctor_args;
- if (options.exists(PDO_ATTR_STATEMENT_CLASS)) {
- Variant opt = options[PDO_ATTR_STATEMENT_CLASS];
- if (!valid_statement_class(m_dbh, opt, clsname, ctor_args)) {
- return false;
- }
- } else {
- clsname = m_dbh->def_stmt_clsname;
- ctor_args = m_dbh->def_stmt_ctor_args;
- }
- Object ret = pdo_stmt_instantiate(m_dbh, clsname, ctor_args);
- if (ret.isNull()) {
- pdo_raise_impl_error
- (m_dbh, nullptr, "HY000",
- "failed to instantiate user-supplied statement class");
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- c_PDOStatement *pdostmt = ret.getTyped<c_PDOStatement>();
- if (m_dbh->preparer(statement, &pdostmt->m_stmt, options)) {
- PDOStatement *stmt = pdostmt->m_stmt.get();
- assert(stmt);
- /* unconditionally keep this for later reference */
- stmt->query_string = statement;
- stmt->default_fetch_type = m_dbh->default_fetch_type;
- stmt->dbh = m_dbh;
- pdo_stmt_construct(stmt, ret, clsname, ctor_args);
- return ret;
- }
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- bool c_PDO::t_begintransaction() {
- if (m_dbh->in_txn) {
- throw_pdo_exception(uninit_null(), uninit_null(), "There is already an active transaction");
- }
- if (m_dbh->begin()) {
- m_dbh->in_txn = 1;
- return true;
- }
- if (strcmp(m_dbh->error_code, PDO_ERR_NONE)) {
- pdo_handle_error(m_dbh, nullptr);
- }
- return false;
- }
- bool c_PDO::t_commit() {
- assert(m_dbh->driver);
- if (!m_dbh->in_txn) {
- throw_pdo_exception(uninit_null(), uninit_null(), "There is no active transaction");
- }
- if (m_dbh->commit()) {
- m_dbh->in_txn = 0;
- return true;
- }
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- bool c_PDO::t_rollback() {
- assert(m_dbh->driver);
- if (!m_dbh->in_txn) {
- throw_pdo_exception(uninit_null(), uninit_null(), "There is no active transaction");
- }
- if (m_dbh->rollback()) {
- m_dbh->in_txn = 0;
- return true;
- }
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- bool c_PDO::t_setattribute(int64_t attribute, CVarRef value) {
- assert(m_dbh->driver);
- #define PDO_LONG_PARAM_CHECK \
- if (!value.isInteger() && !value.isString() && !value.isBoolean()) { \
- pdo_raise_impl_error(m_dbh, nullptr, "HY000", \
- "attribute value must be an integer"); \
- PDO_HANDLE_DBH_ERR(m_dbh); \
- return false; \
- } \
- switch (attribute) {
- case PDO_ATTR_ERRMODE:
- PDO_LONG_PARAM_CHECK;
- switch (value.toInt64()) {
- case PDO_ERRMODE_SILENT:
- case PDO_ERRMODE_WARNING:
- case PDO_ERRMODE_EXCEPTION:
- m_dbh->error_mode = (PDOErrorMode)value.toInt64();
- return true;
- default:
- pdo_raise_impl_error(m_dbh, nullptr, "HY000", "invalid error mode");
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- return false;
- case PDO_ATTR_CASE:
- PDO_LONG_PARAM_CHECK;
- switch (value.toInt64()) {
- case PDO_CASE_NATURAL:
- case PDO_CASE_UPPER:
- case PDO_CASE_LOWER:
- m_dbh->desired_case = (PDOCaseConversion)value.toInt64();
- return true;
- default:
- pdo_raise_impl_error(m_dbh, nullptr, "HY000",
- "invalid case folding mode");
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- return false;
- case PDO_ATTR_ORACLE_NULLS:
- PDO_LONG_PARAM_CHECK;
- m_dbh->oracle_nulls = value.toInt64();
- return true;
- case PDO_ATTR_DEFAULT_FETCH_MODE:
- if (value.isArray()) {
- if (value.toArray().exists(0)) {
- Variant tmp = value[0];
- if (tmp.isInteger() && ((tmp.toInt64() == PDO_FETCH_INTO ||
- tmp.toInt64() == PDO_FETCH_CLASS))) {
- pdo_raise_impl_error(m_dbh, nullptr, "HY000",
- "FETCH_INTO and FETCH_CLASS are not yet "
- "supported as default fetch modes");
- return false;
- }
- }
- } else {
- PDO_LONG_PARAM_CHECK;
- }
- if (value.toInt64() == PDO_FETCH_USE_DEFAULT) {
- pdo_raise_impl_error(m_dbh, nullptr, "HY000", "invalid fetch mode type");
- return false;
- }
- m_dbh->default_fetch_type = (PDOFetchType)value.toInt64();
- return true;
- case PDO_ATTR_STRINGIFY_FETCHES:
- PDO_LONG_PARAM_CHECK;
- m_dbh->stringify = value.toInt64() ? 1 : 0;
- return true;
- case PDO_ATTR_STATEMENT_CLASS:
- {
- if (m_dbh->is_persistent) {
- pdo_raise_impl_error(m_dbh, nullptr, "HY000",
- "PDO::ATTR_STATEMENT_CLASS cannot be used "
- "with persistent PDO instances");
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- String clsname;
- if (!valid_statement_class(m_dbh, value, clsname,
- m_dbh->def_stmt_ctor_args)) {
- return false;
- }
- m_dbh->def_stmt_clsname = clsname.c_str();
- return true;
- }
- }
- if (m_dbh->support(PDOConnection::MethodSetAttribute)) {
- strcpy(m_dbh->error_code, PDO_ERR_NONE);
- m_dbh->query_stmt = NULL;
- if (m_dbh->setAttribute(attribute, value)) {
- return true;
- }
- }
- if (attribute == PDO_ATTR_AUTOCOMMIT) {
- throw_pdo_exception(uninit_null(), uninit_null(),
- "The auto-commit mode cannot be changed for this "
- "driver");
- } else if (!m_dbh->support(PDOConnection::MethodSetAttribute)) {
- pdo_raise_impl_error(m_dbh, nullptr, "IM001",
- "driver does not support setting attributes");
- } else {
- PDO_HANDLE_DBH_ERR(m_dbh);
- }
- return false;
- }
- Variant c_PDO::t_getattribute(int64_t attribute) {
- assert(m_dbh->driver);
- strcpy(m_dbh->error_code, PDO_ERR_NONE);
- m_dbh->query_stmt = NULL;
- /* handle generic PDO-level atributes */
- switch (attribute) {
- case PDO_ATTR_PERSISTENT:
- return (bool)m_dbh->is_persistent;
- case PDO_ATTR_CASE:
- return (int64_t)m_dbh->desired_case;
- case PDO_ATTR_ORACLE_NULLS:
- return (int64_t)m_dbh->oracle_nulls;
- case PDO_ATTR_ERRMODE:
- return (int64_t)m_dbh->error_mode;
- case PDO_ATTR_DRIVER_NAME:
- return String(m_dbh->driver->getName());
- case PDO_ATTR_STATEMENT_CLASS: {
- Array ret;
- ret.append(String(m_dbh->def_stmt_clsname));
- if (!m_dbh->def_stmt_ctor_args.isNull()) {
- ret.append(m_dbh->def_stmt_ctor_args);
- }
- return ret;
- }
- case PDO_ATTR_DEFAULT_FETCH_MODE:
- return (int64_t)m_dbh->default_fetch_type;
- }
- if (!m_dbh->support(PDOConnection::MethodGetAttribute)) {
- pdo_raise_impl_error(m_dbh, nullptr, "IM001",
- "driver does not support getting attributes");
- return false;
- }
- Variant ret;
- switch (m_dbh->getAttribute(attribute, ret)) {
- case -1:
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- case 0:
- pdo_raise_impl_error(m_dbh, nullptr, "IM001",
- "driver does not support that attribute");
- return false;
- }
- return ret;
- }
- Variant c_PDO::t_exec(const String& query) {
- if (query.empty()) {
- pdo_raise_impl_error(m_dbh, nullptr, "HY000",
- "trying to execute an empty query");
- return false;
- }
- assert(m_dbh->driver);
- strcpy(m_dbh->error_code, PDO_ERR_NONE);
- m_dbh->query_stmt = NULL;
- int64_t ret = m_dbh->doer(query);
- if (ret == -1) {
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- return ret;
- }
- Variant c_PDO::t_lastinsertid(const String& seqname /* = null_string */) {
- assert(m_dbh->driver);
- strcpy(m_dbh->error_code, PDO_ERR_NONE);
- m_dbh->query_stmt = NULL;
- if (!m_dbh->support(PDOConnection::MethodLastId)) {
- pdo_raise_impl_error(m_dbh, nullptr, "IM001",
- "driver does not support lastInsertId()");
- return false;
- }
- String ret = m_dbh->lastId(seqname.data());
- if (ret.empty()) {
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- return ret;
- }
- Variant c_PDO::t_errorcode() {
- assert(m_dbh->driver);
- if (m_dbh->query_stmt) {
- return String(m_dbh->query_stmt->error_code, CopyString);
- }
- if (m_dbh->error_code[0] == '\0') {
- return uninit_null();
- }
- /**
- * Making sure that we fallback to the default implementation
- * if the dbh->error_code is not null.
- */
- return String(m_dbh->error_code, CopyString);
- }
- Array c_PDO::t_errorinfo() {
- assert(m_dbh->driver);
- Array ret;
- if (m_dbh->query_stmt) {
- ret.append(String(m_dbh->query_stmt->error_code, CopyString));
- } else {
- ret.append(String(m_dbh->error_code, CopyString));
- }
- if (m_dbh->support(PDOConnection::MethodFetchErr)) {
- m_dbh->fetchErr(m_dbh->query_stmt, ret);
- }
- /**
- * In order to be consistent, we have to make sure we add the good amount
- * of nulls depending on the current number of elements. We make a simple
- * difference and add the needed elements
- */
- int error_count = ret.size();
- int error_expected_count = 3;
- if (error_expected_count > error_count) {
- int error_count_diff = error_expected_count - error_count;
- for (int i = 0; i < error_count_diff; i++) {
- ret.append(uninit_null());
- }
- }
- return ret;
- }
- Variant c_PDO::t_query(const String& sql) {
- assert(m_dbh->driver);
- strcpy(m_dbh->error_code, PDO_ERR_NONE);
- m_dbh->query_stmt = NULL;
- Object ret = pdo_stmt_instantiate(m_dbh, m_dbh->def_stmt_clsname,
- m_dbh->def_stmt_ctor_args);
- if (ret.isNull()) {
- pdo_raise_impl_error
- (m_dbh, nullptr, "HY000",
- "failed to instantiate user supplied statement class");
- return uninit_null();
- }
- c_PDOStatement *pdostmt = ret.getTyped<c_PDOStatement>();
- if (m_dbh->preparer(sql, &pdostmt->m_stmt, Array())) {
- PDOStatement *stmt = pdostmt->m_stmt.get();
- assert(stmt);
- /* unconditionally keep this for later reference */
- stmt->query_string = sql;
- stmt->default_fetch_type = m_dbh->default_fetch_type;
- stmt->active_query_string = stmt->query_string;
- stmt->dbh = m_dbh;
- stmt->lazy_object_ref = uninit_null();
- strcpy(stmt->error_code, PDO_ERR_NONE);
- // when we add support for varargs here, we only need to set the stmt if
- // the argument count is > 1
- if (true || pdo_stmt_set_fetch_mode(stmt, 0, PDO_FETCH_BOTH, Array())) {
- /* now execute the statement */
- strcpy(stmt->error_code, PDO_ERR_NONE);
- if (stmt->executer()) {
- int ok = 1;
- if (!stmt->executed) {
- if (stmt->dbh->alloc_own_columns) {
- ok = pdo_stmt_describe_columns(stmt);
- }
- stmt->executed = 1;
- }
- if (ok) {
- pdo_stmt_construct(stmt, ret, m_dbh->def_stmt_clsname,
- m_dbh->def_stmt_ctor_args);
- return ret;
- }
- }
- }
- /* something broke */
- m_dbh->query_stmt = stmt;
- PDO_HANDLE_STMT_ERR(stmt);
- } else {
- PDO_HANDLE_DBH_ERR(m_dbh);
- }
- return false;
- }
- Variant c_PDO::t_quote(const String& str, int64_t paramtype /* = q_PDO$$PARAM_STR */) {
- assert(m_dbh->driver);
- strcpy(m_dbh->error_code, PDO_ERR_NONE);
- m_dbh->query_stmt = NULL;
- if (!m_dbh->support(PDOConnection::MethodQuoter)) {
- pdo_raise_impl_error(m_dbh, nullptr, "IM001",
- "driver does not support quoting");
- return false;
- }
- String quoted;
- if (m_dbh->quoter(str, quoted, (PDOParamType)paramtype)) {
- return quoted;
- }
- PDO_HANDLE_DBH_ERR(m_dbh);
- return false;
- }
- bool c_PDO::t_sqlitecreatefunction(const String& name,
- CVarRef callback,
- int64_t argcount /* = -1 */) {
- raise_recoverable_error("PDO::sqliteCreateFunction not implemented");
- return false;
- }
- bool c_PDO::t_sqlitecreateaggregate(const String& name,
- CVarRef step, CVarRef final,
- int64_t argcount /* = -1 */) {
- raise_recoverable_error("PDO::sqliteCreateAggregate not implemented");
- return false;
- }
- Variant c_PDO::t___wakeup() {
- throw_pdo_exception(uninit_null(), uninit_null(),
- "You cannot serialize or unserialize PDO instances");
- return uninit_null();
- }
- Variant c_PDO::t___sleep() {
- throw_pdo_exception(uninit_null(), uninit_null(),
- "You cannot serialize or unserialize PDO instances");
- return uninit_null();
- }
- Array c_PDO::ti_getavailabledrivers() {
- return f_pdo_drivers();
- }
- ///////////////////////////////////////////////////////////////////////////////
- static inline bool rewrite_name_to_position(sp_PDOStatement stmt,
- PDOBoundParam *param) {
- if (!stmt->bound_param_map.empty()) {
- /* rewriting :name to ? style.
- * We need to fixup the parameter numbers on the parameters.
- * If we find that a given named parameter has been used twice,
- * we will raise an error, as we can't be sure that it is safe
- * to bind multiple parameters onto the same zval in the underlying
- * driver */
- if (stmt->named_rewrite_template) {
- /* this is not an error here */
- return true;
- }
- if (param->name.empty()) {
- /* do the reverse; map the parameter number to the name */
- if (stmt->bound_param_map.exists(param->paramno)) {
- param->name = stmt->bound_param_map[param->paramno].toString();
- return true;
- }
- pdo_raise_impl_error(stmt->dbh, stmt, "HY093",
- "parameter was not defined");
- return false;
- }
- int position = 0;
- for (ArrayIter iter(stmt->bound_param_map); iter; ++iter, ++position) {
- if (iter.second().toString() == param->name) {
- if (param->paramno >= 0) {
- pdo_raise_impl_error
- (stmt->dbh, stmt, "IM001",
- "PDO refuses to handle repeating the same :named parameter "
- "for multiple positions with this driver, as it might be "
- "unsafe to do so. Consider using a separate name for each "
- "parameter instead");
- return true;
- }
- param->paramno = position;
- return true;
- }
- }
- pdo_raise_impl_error(stmt->dbh, stmt, "HY093",
- "parameter was not defined");
- return false;
- }
- return true;
- }
- /* trigger callback hook for parameters */
- static bool dispatch_param_event(sp_PDOStatement stmt,
- PDOParamEvent event_type) {
- if (!stmt->support(PDOStatement::MethodParamHook)) {
- return true;
- }
- for (ArrayIter iter(stmt->bound_params); iter; ++iter) {
- PDOBoundParam *param = iter.second().toResource().getTyped<PDOBoundParam>();
- if (!stmt->paramHook(param, event_type)) {
- return false;
- }
- }
- for (ArrayIter iter(stmt->bound_columns); iter; ++iter) {
- PDOBoundParam *param = iter.second().toResource().getTyped<PDOBoundParam>();
- if (!stmt->paramHook(param, event_type)) {
- return false;
- }
- }
- return true;
- }
- static void get_lazy_object(sp_PDOStatement stmt, Variant &ret) {
- if (stmt->lazy_object_ref.isNull()) {
- stmt->lazy_object_ref = stmt;
- }
- ret = stmt->lazy_object_ref;
- }
- static bool really_register_bound_param(PDOBoundParam *param,
- sp_PDOStatement stmt, bool is_param) {
- Array &hash = is_param ? stmt->bound_params : stmt->bound_columns;
- if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_STR &&
- param->max_value_len <= 0 && !param->parameter.isNull()) {
- param->parameter = param->parameter.toString();
- } else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_INT &&
- param->parameter.isBoolean()) {
- param->parameter = param->parameter.toInt64();
- } else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_BOOL &&
- param->parameter.isInteger()) {
- param->parameter = param->parameter.toBoolean();
- }
- param->stmt = stmt.get();
- param->is_param = is_param;
- if (!is_param && !param->name.empty() && !stmt->columns.empty()) {
- /* try to map the name to the column */
- for (int i = 0; i < stmt->column_count; i++) {
- if (stmt->columns[i].toResource().getTyped<PDOColumn>()->name ==
- param->name) {
- param->paramno = i;
- break;
- }
- }
- /* if you prepare and then execute passing an array of params keyed by
- names, then this will trigger, and we don't want that */
- if (param->paramno == -1) {
- raise_warning("Did not found column name '%s' in the defined columns;"
- " it will not be bound", param->name.data());
- }
- }
- if (is_param && !param->name.empty() && param->name[0] != ':') {
- param->name = String(":") + param->name;
- }
- if (is_param && !rewrite_name_to_position(stmt, param)) {
- param->name.reset();
- return false;
- }
- /* ask the driver to perform any normalization it needs on the
- * parameter name. Note that it is illegal for the driver to take
- * a reference to param, as it resides in transient storage only
- * at this time. */
- if (stmt->support(PDOStatement::MethodParamHook)) {
- if (!stmt->paramHook(param, PDO_PARAM_EVT_NORMALIZE)) {
- param->name.reset();
- return false;
- }
- }
- /* delete any other parameter registered with this number.
- * If the parameter is named, it will be removed and correctly
- * disposed of by the hash_update call that follows */
- if (param->paramno >= 0) {
- hash.remove(param->paramno);
- }
- /* allocate storage for the parameter, keyed by its "canonical" name */
- if (!param->name.empty()) {
- hash.set(param->name, param);
- } else {
- hash.set(param->paramno, param);
- }
- /* tell the driver we just created a parameter */
- if (stmt->support(PDOStatement::MethodParamHook)) {
- if (!stmt->paramHook(param, PDO_PARAM_EVT_ALLOC)) {
- /* undo storage allocation; the hash will free the parameter
- * name if required */
- if (!param->name.empty()) {
- hash.remove(param->name);
- } else {
- hash.remove(param->paramno);
- }
- /* param->parameter is freed by hash dtor */
- param->parameter.reset();
- return false;
- }
- }
- return true;
- }
- static inline void fetch_value(sp_PDOStatement stmt, Variant &dest, int colno,
- int *type_override) {
- PDOColumn *col = stmt->columns[colno].toResource().getTyped<PDOColumn>();
- int type = PDO_PARAM_TYPE(col->param_type);
- int new_type = type_override ? PDO_PARAM_TYPE(*type_override) : type;
- stmt->getColumn(colno, dest);
- if (type != new_type) {
- switch (new_type) {
- case PDO_PARAM_INT: dest = dest.toInt64(); break;
- case PDO_PARAM_BOOL: dest = dest.toBoolean(); break;
- case PDO_PARAM_STR: dest = dest.toString(); break;
- case PDO_PARAM_NULL: dest = uninit_null(); break;
- }
- }
- if (stmt->dbh->stringify && (dest.isInteger() || dest.isDouble())) {
- dest = dest.toString();
- }
- if (dest.isNull() && stmt->dbh->oracle_nulls == PDO_NULL_TO_STRING) {
- dest = empty_string;
- }
- }
- static bool do_fetch_common(sp_PDOStatement stmt, PDOFetchOrientation ori,
- long offset, bool do_bind) {
- if (!stmt->executed) {
- return false;
- }
- if (!dispatch_param_event(stmt, PDO_PARAM_EVT_FETCH_PRE)) {
- return false;
- }
- if (!stmt->fetcher(ori, offset)) {
- return false;
- }
- /* some drivers might need to describe the columns now */
- if (stmt->columns.empty() && !pdo_stmt_describe_columns(stmt)) {
- return false;
- }
- if (!dispatch_param_event(stmt, PDO_PARAM_EVT_FETCH_POST)) {
- return false;
- }
- if (do_bind && !stmt->bound_columns.empty()) {
- /* update those bound column variables now */
- for (ArrayIter iter(stmt->bound_columns); iter; ++iter) {
- PDOBoundParam *param =
- iter.second().toResource().getTyped<PDOBoundParam>();
- if (param->paramno >= 0) {
- param->parameter.reset();
- /* set new value */
- fetch_value(stmt, param->parameter, param->paramno,
- (int *)¶m->param_type);
- /* TODO: some smart thing that avoids duplicating the value in the
- * general loop below. For now, if you're binding output columns,
- * it's better to use LAZY or BOUND fetches if you want to shave
- * off those cycles */
- }
- }
- }
- return true;
- }
- static bool do_fetch_func_prepare(sp_PDOStatement stmt) {
- if (!f_is_callable(stmt->fetch.func)) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "user-supplied function must be a valid callback");
- return false;
- }
- return true;
- }
- /* perform a fetch. If do_bind is true, update any bound columns.
- * If return_value is not null, store values into it according to HOW. */
- static bool do_fetch(sp_PDOStatement stmt, bool do_bind, Variant &ret,
- PDOFetchType how, PDOFetchOrientation ori,
- long offset, Variant *return_all) {
- if (how == PDO_FETCH_USE_DEFAULT) {
- how = stmt->default_fetch_type;
- }
- int flags = how & PDO_FETCH_FLAGS;
- how = (PDOFetchType)(how & ~PDO_FETCH_FLAGS);
- if (!do_fetch_common(stmt, ori, offset, do_bind)) {
- return false;
- }
- if (how == PDO_FETCH_BOUND) {
- ret = true;
- return true;
- }
- int colno;
- if ((flags & PDO_FETCH_GROUP) && stmt->fetch.column == -1) {
- colno = 1;
- } else {
- colno = stmt->fetch.column;
- }
- if (how == PDO_FETCH_LAZY) {
- get_lazy_object(stmt, ret);
- return true;
- }
- String clsname, old_clsname;
- Variant old_ctor_args;
- ret = false;
- int i = 0;
- switch (how) {
- case PDO_FETCH_USE_DEFAULT:
- case PDO_FETCH_ASSOC:
- case PDO_FETCH_BOTH:
- case PDO_FETCH_NUM:
- case PDO_FETCH_NAMED:
- ret = Array::Create();
- break;
- case PDO_FETCH_KEY_PAIR:
- if (stmt->column_count != 2) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "PDO::FETCH_KEY_PAIR fetch mode requires the "
- "result set to contain extactly 2 columns.");
- return false;
- }
- if (!return_all) {
- ret = Array::Create();
- }
- break;
- case PDO_FETCH_COLUMN:
- if (colno >= 0 && colno < stmt->column_count) {
- if (flags == PDO_FETCH_GROUP && stmt->fetch.column == -1) {
- fetch_value(stmt, ret, 1, NULL);
- } else if (flags == PDO_FETCH_GROUP && colno) {
- fetch_value(stmt, ret, 0, NULL);
- } else {
- fetch_value(stmt, ret, colno, NULL);
- }
- if (!return_all) {
- return true;
- }
- break;
- } else {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Invalid column index");
- }
- return false;
- case PDO_FETCH_OBJ:
- ret = SystemLib::AllocStdClassObject();
- break;
- case PDO_FETCH_CLASS:
- if (flags & PDO_FETCH_CLASSTYPE) {
- old_clsname = stmt->fetch.clsname;
- old_ctor_args = stmt->fetch.ctor_args;
- Variant val;
- fetch_value(stmt, val, i++, NULL);
- if (!val.isNull()) {
- if (!f_class_exists(val.toString())) {
- stmt->fetch.clsname = "stdclass";
- } else {
- stmt->fetch.clsname = val.toString();
- }
- }
- do_fetch_class_prepare(stmt);
- }
- clsname = stmt->fetch.clsname;
- if (clsname.empty()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "No fetch class specified");
- return false;
- }
- if ((flags & PDO_FETCH_SERIALIZE) == 0) {
- ret = create_object_only(clsname);
- if (!do_fetch_class_prepare(stmt)) {
- return false;
- }
- if (!stmt->fetch.constructor.empty() &&
- (flags & PDO_FETCH_PROPS_LATE)) {
- ret.asCObjRef().get()->o_invoke(stmt->fetch.constructor,
- stmt->fetch.ctor_args.toArray());
- ret.asCObjRef().get()->clearNoDestruct();
- }
- }
- break;
- case PDO_FETCH_INTO:
- if (stmt->fetch.into.isNull()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "No fetch-into object specified.");
- return false;
- }
- ret = stmt->fetch.into;
- if (ret.instanceof(SystemLib::s_stdclassClass)) {
- how = PDO_FETCH_OBJ;
- }
- break;
- case PDO_FETCH_FUNC:
- if (stmt->fetch.func.empty()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "No fetch function specified");
- return false;
- }
- if (!do_fetch_func_prepare(stmt)) {
- return false;
- }
- break;
- default:
- assert(false);
- return false;
- }
- Variant grp_val;
- if (return_all && how != PDO_FETCH_KEY_PAIR) {
- if (flags == PDO_FETCH_GROUP && how == PDO_FETCH_COLUMN &&
- stmt->fetch.column > 0) {
- fetch_value(stmt, grp_val, colno, NULL);
- } else {
- fetch_value(stmt, grp_val, i, NULL);
- }
- grp_val = grp_val.toString();
- if (how == PDO_FETCH_COLUMN) {
- i = stmt->column_count; /* no more data to fetch */
- } else {
- i++;
- }
- }
- for (int idx = 0; i < stmt->column_count; i++, idx++) {
- String name = stmt->columns[i].toResource().getTyped<PDOColumn>()->name;
- Variant val;
- fetch_value(stmt, val, i, NULL);
- switch (how) {
- case PDO_FETCH_ASSOC:
- ret.set(name, val);
- break;
- case PDO_FETCH_KEY_PAIR: {
- Variant tmp;
- fetch_value(stmt, tmp, ++i, NULL);
- if (return_all) {
- return_all->set(val, tmp);
- } else {
- ret.set(val, tmp);
- }
- return true;
- }
- case PDO_FETCH_USE_DEFAULT:
- case PDO_FETCH_BOTH:
- ret.set(name, val);
- ret.append(val);
- break;
- case PDO_FETCH_NAMED: {
- /* already have an item with this name? */
- if (ret.toArray().exists(name)) {
- Variant &curr_val = ret.lvalAt(name);
- if (!curr_val.isArray()) {
- Array arr = Array::Create();
- arr.append(curr_val);
- arr.append(val);
- ret.set(name, arr);
- } else {
- curr_val.append(val);
- }
- } else {
- ret.set(name, val);
- }
- break;
- }
- case PDO_FETCH_NUM:
- ret.append(val);
- break;
- case PDO_FETCH_OBJ:
- case PDO_FETCH_INTO:
- ret.toObject()->o_set(name, val);
- break;
- case PDO_FETCH_CLASS:
- if ((flags & PDO_FETCH_SERIALIZE) == 0 || idx) {
- ret.toObject()->o_set(name, val);
- } else {
- #ifdef MBO_0
- ret = unserialize_from_string(val);
- if (same(ret, false)) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "cannot unserialize data");
- return false;
- }
- #endif
- // hzhao: not sure how we support class serialization
- pdo_raise_impl_error(stmt->dbh, stmt, "HY000",
- "cannot unserialize class");
- return false;
- }
- break;
- case PDO_FETCH_FUNC:
- stmt->fetch.values.set(idx, val);
- break;
- default:
- pdo_raise_impl_error(stmt->dbh, stmt, "22003", "mode is out of range");
- return false;
- }
- }
- switch (how) {
- case PDO_FETCH_CLASS:
- if (!stmt->fetch.constructor.empty() &&
- !(flags & (PDO_FETCH_PROPS_LATE | PDO_FETCH_SERIALIZE))) {
- ret.toObject()->o_invoke(stmt->fetch.constructor,
- stmt->fetch.ctor_args.toArray());
- ret.toObject()->clearNoDestruct();
- }
- if (flags & PDO_FETCH_CLASSTYPE) {
- stmt->fetch.clsname = old_clsname;
- stmt->fetch.ctor_args = old_ctor_args;
- }
- break;
- case PDO_FETCH_FUNC:
- ret = vm_call_user_func(stmt->fetch.func,
- stmt->fetch.values.toArray());
- break;
- default:
- break;
- }
- if (return_all) {
- if ((flags & PDO_FETCH_UNIQUE) == PDO_FETCH_UNIQUE) {
- return_all->set(grp_val, ret);
- } else {
- return_all->lvalAt(grp_val).append(ret);
- }
- }
- return true;
- }
- static int register_bound_param(CVarRef paramno, VRefParam param, int64_t type,
- int64_t max_value_len, CVarRef driver_params,
- sp_PDOStatement stmt, bool is_param) {
- SmartResource<PDOBoundParam> p(new PDOBoundParam);
- // need to make sure this is NULL, in case a fatal errors occurs before its set
- // inside really_register_bound_param
- p->stmt = NULL;
- if (paramno.isNumeric()) {
- p->paramno = paramno.toInt64();
- } else {
- p->paramno = -1;
- p->name = paramno.toString();
- }
- p->parameter.setWithRef(param);
- p->param_type = (PDOParamType)type;
- p->max_value_len = max_value_len;
- p->driver_params = driver_params;
- if (p->paramno > 0) {
- --p->paramno; /* make it zero-based internally */
- } else if (p->name.empty()) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY093",
- "Columns/Parameters are 1-based");
- return false;
- }
- if (!really_register_bound_param(p.get(), stmt, is_param)) {
- p->parameter.reset();
- return false;
- }
- return true;
- }
- static bool generic_stmt_attr_get(sp_PDOStatement stmt, Variant &ret,
- long attr) {
- if (attr == PDO_ATTR_EMULATE_PREPARES) {
- ret = (bool)(stmt->supports_placeholders == PDO_PLACEHOLDER_NONE);
- return true;
- }
- return false;
- }
- ///////////////////////////////////////////////////////////////////////////////
- // SQL parser
- #define PDO_PARSER_TEXT 1
- #define PDO_PARSER_BIND 2
- #define PDO_PARSER_BIND_POS 3
- #define PDO_PARSER_EOI 4
- #define RET(i) {s->cur = cursor; return i; }
- #define SKIP_ONE(i) {s->cur = s->tok + 1; return 1; }
- #define YYCTYPE unsigned char
- #define YYCURSOR cursor
- #define YYLIMIT cursor
- #define YYMARKER s->ptr
- #define YYFILL(n)
- typedef struct Scanner {
- char *ptr, *cur, *tok;
- } Scanner;
- static int scan(Scanner *s) {
- char *cursor = s->cur;
- s->tok = cursor;
- {
- YYCTYPE yych;
- if ((YYLIMIT - YYCURSOR) < 2) { YYFILL(2); }
- yych = *YYCURSOR;
- switch (yych) {
- case 0x00: goto yy11;
- case '"': goto yy2;
- case '\'': goto yy4;
- case ':': goto yy5;
- case '?': goto yy6;
- default: goto yy8;
- }
- yy2:
- yych = *(YYMARKER = ++YYCURSOR);
- if (yych >= 0x01) goto yy26;
- yy3:
- { SKIP_ONE(PDO_PARSER_TEXT); }
- yy4:
- yych = *(YYMARKER = ++YYCURSOR);
- if (yych <= 0x00) goto yy3;
- goto yy20;
- yy5:
- yych = *++YYCURSOR;
- switch (yych) {
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- case 'A':
- case 'B':
- case 'C':
- case 'D':
- case 'E':
- case 'F':
- case 'G':
- case 'H':
- case 'I':
- case 'J':
- case 'K':
- case 'L':
- case 'M':
- case 'N':
- case 'O':
- case 'P':
- case 'Q':
- case 'R':
- case 'S':
- case 'T':
- case 'U':
- case 'V':
- case 'W':
- case 'X':
- case 'Y':
- case 'Z':
- case '_':
- case 'a':
- case 'b':
- case 'c':
- case 'd':
- case 'e':
- case 'f':
- case 'g':
- case 'h':
- case 'i':
- case 'j':
- case 'k':
- case 'l':
- case 'm':
- case 'n':
- case 'o':
- case 'p':
- case 'q':
- case 'r':
- case 's':
- case 't':
- case 'u':
- case 'v':
- case 'w':
- case 'x':
- case 'y':
- case 'z': goto yy16;
- case ':':
- case '?': goto yy13;
- default: goto yy3;
- }
- yy6:
- ++YYCURSOR;
- switch ((yych = *YYCURSOR)) {
- case ':':
- case '?': goto yy13;
- default: goto yy7;
- }
- yy7:
- { RET(PDO_PARSER_BIND_POS); }
- yy8:
- ++YYCURSOR;
- if (YYLIMIT <= YYCURSOR) { YYFILL(1); }
- yych = *YYCURSOR;
- switch (yych) {
- case 0x00:
- case '"':
- case '\'':
- case ':':
- case '?': goto yy10;
- default: goto yy8;
- }
- yy10:
- { RET(PDO_PARSER_TEXT); }
- yy11:
- ++YYCURSOR;
- { RET(PDO_PARSER_EOI); }
- yy13:
- ++YYCURSOR;
- if (YYLIMIT <= YYCURSOR) { YYFILL(1); }
- yych = *YYCURSOR;
- switch (yych) {
- case ':':
- case '?': goto yy13;
- default: goto yy15;
- }
- yy15:
- { RET(PDO_PARSER_TEXT); }
- yy16:
- ++YYCURSOR;
- if (YYLIMIT <= YYCURSOR) { YYFILL(1); }
- yych = *YYCURSOR;
- switch (yych) {
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- case 'A':
- case 'B':
- case 'C':
- case 'D':
- case 'E':
- case 'F':
- case 'G':
- case 'H':
- case 'I':
- case 'J':
- case 'K':
- case 'L':
- case 'M':
- case 'N':
- case 'O':
- case 'P':
- case 'Q':
- case 'R':
- case 'S':
- case 'T':
- case 'U':
- case 'V':
- case 'W':
- case 'X':
- case 'Y':
- case 'Z':
- case '_':
- case 'a':
- case 'b':
- case 'c':
- case 'd':
- case 'e':
- case 'f':
- case 'g':
- case 'h':
- case 'i':
- case 'j':
- case 'k':
- case 'l':
- case 'm':
- case 'n':
- case 'o':
- case 'p':
- case 'q':
- case 'r':
- case 's':
- case 't':
- case 'u':
- case 'v':
- case 'w':
- case 'x':
- case 'y':
- case 'z': goto yy16;
- default: goto yy18;
- }
- yy18:
- { RET(PDO_PARSER_BIND); }
- yy19:
- ++YYCURSOR;
- if (YYLIMIT <= YYCURSOR) { YYFILL(1); }
- yych = *YYCURSOR;
- yy20:
- switch (yych) {
- case 0x00: goto yy21;
- case '\'': goto yy23;
- case '\\': goto yy22;
- default: goto yy19;
- }
- yy21:
- YYCURSOR = YYMARKER;
- goto yy3;
- yy22:
- ++YYCURSOR;
- if (YYLIMIT <= YYCURSOR) { YYFILL(1); }
- yych = *YYCURSOR;
- if (yych <= 0x00) goto yy21;
- goto yy19;
- yy23:
- ++YYCURSOR;
- { RET(PDO_PARSER_TEXT); }
- yy25:
- ++YYCURSOR;
- if (YYLIMIT <= YYCURSOR) { YYFILL(1); }
- yych = *YYCURSOR;
- yy26:
- switch (yych) {
- case 0x00: goto yy21;
- case '"': goto yy28;
- case '\\': goto yy27;
- default: goto yy25;
- }
- yy27:
- ++YYCURSOR;
- if (YYLIMIT <= YYCURSOR) { YYFILL(1); }
- yych = *YYCURSOR;
- if (yych <= 0x00) goto yy21;
- goto yy25;
- yy28:
- ++YYCURSOR;
- { RET(PDO_PARSER_TEXT); }
- }
- }
- struct placeholder {
- char *pos;
- int len;
- int bindno;
- String quoted; /* quoted value */
- struct placeholder *next;
- };
- int pdo_parse_params(PDOStatement *stmt, const String& in, String &out) {
- Scanner s;
- const char *ptr;
- char *newbuffer;
- int t;
- int bindno = 0;
- int ret = 0;
- int newbuffer_len;
- Array params;
- PDOBoundParam *param;
- int query_type = PDO_PLACEHOLDER_NONE;
- struct placeholder *placeholders = NULL, *placetail = NULL, *plc = NULL;
- s.cur = (char*)in.data();
- /* phase 1: look for args */
- while ((t = scan(&s)) != PDO_PARSER_EOI) {
- if (t == PDO_PARSER_BIND || t == PDO_PARSER_BIND_POS) {
- if (t == PDO_PARSER_BIND) {
- int len = s.cur - s.tok;
- if ((in.data() < (s.cur - len)) && isalnum(*(s.cur - len - 1))) {
- continue;
- }
- query_type |= PDO_PLACEHOLDER_NAMED;
- } else {
- query_type |= PDO_PLACEHOLDER_POSITIONAL;
- }
- plc = (placeholder*)malloc(sizeof(*plc));
- memset(plc, 0, sizeof(*plc));
- plc->next = NULL;
- plc->pos = s.tok;
- plc->len = s.cur - s.tok;
- plc->bindno = bindno++;
- if (placetail) {
- placetail->next = plc;
- } else {
- placeholders = plc;
- }
- placetail = plc;
- }
- }
- if (bindno == 0) {
- /* nothing to do; good! */
- return 0;
- }
- /* did the query make sense to me? */
- if (query_type == (PDO_PLACEHOLDER_NAMED|PDO_PLACEHOLDER_POSITIONAL)) {
- /* they mixed both types; punt */
- pdo_raise_impl_error(stmt->dbh, stmt, "HY093",
- "mixed named and positional parameters");
- ret = -1;
- goto clean_up;
- }
- if ((int)stmt->supports_placeholders == query_type &&
- !stmt->named_rewrite_template) {
- /* query matches native syntax */
- ret = 0;
- goto clean_up;
- }
- if (stmt->named_rewrite_template) {
- /* magic/hack.
- * We we pretend that the query was positional even if
- * it was named so that we fall into the
- * named rewrite case below. Not too pretty,
- * but it works. */
- query_type = PDO_PLACEHOLDER_POSITIONAL;
- }
- params = stmt->bound_params;
- /* Do we have placeholders but no bound params */
- if (bindno && params.empty() &&
- stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "no parameters were bound");
- ret = -1;
- goto clean_up;
- }
- if (!params.empty() && bindno != params.size() &&
- stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
- /* extra bit of validation for instances when same params are bound
- more then once */
- if (query_type != PDO_PLACEHOLDER_POSITIONAL && bindno > params.size()) {
- int ok = 1;
- for (plc = placeholders; plc; plc = plc->next) {
- if (!params.exists(String(plc->pos, plc->len, CopyString))) {
- ok = 0;
- break;
- }
- }
- if (ok) {
- goto safe;
- }
- }
- pdo_raise_impl_error(stmt->dbh, stmt, "HY093",
- "number of bound variables does not match number "
- "of tokens");
- ret = -1;
- goto clean_up;
- }
- safe:
- /* what are we going to do ? */
- if (stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
- /* query generation */
- newbuffer_len = in.size();
- /* let's quote all the values */
- for (plc = placeholders; plc; plc = plc->next) {
- Variant vparam;
- if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
- vparam = params[plc->bindno];
- } else {
- vparam = params[String(plc->pos, plc->len, CopyString)];
- }
- if (vparam.isNull()) {
- /* parameter was not defined */
- ret = -1;
- pdo_raise_impl_error(stmt->dbh, stmt, "HY093",
- "parameter was not defined");
- goto clean_up;
- }
- param = vparam.toResource().getTyped<PDOBoundParam>();
- if (stmt->dbh->support(PDOConnection::MethodQuoter)) {
- if (param->param_type == PDO_PARAM_LOB &&
- param->parameter.isResource()) {
- Variant buf = f_stream_get_contents(param->parameter.toResource());
- if (!same(buf, false)) {
- if (!stmt->dbh->quoter(buf.toString(), plc->quoted,
- param->param_type)) {
- /* bork */
- ret = -1;
- strcpy(stmt->error_code, stmt->dbh->error_code);
- goto clean_up;
- }
- } else {
- pdo_raise_impl_error(stmt->dbh, stmt, "HY105",
- "Expected a stream resource");
- ret = -1;
- goto clean_up;
- }
- } else {
- switch (param->parameter.getType()) {
- case KindOfUninit:
- case KindOfNull:
- plc->quoted = "NULL";
- break;
- case KindOfInt64:
- case KindOfDouble:
- plc->quoted = param->parameter.toString();
- break;
- case KindOfBoolean:
- param->parameter = param->parameter.toInt64();
- default:
- if (!stmt->dbh->quoter(param->parameter.toString(), plc->quoted,
- param->param_type)) {
- /* bork */
- ret = -1;
- strcpy(stmt->error_code, stmt->dbh->error_code);
- goto clean_up;
- }
- }
- }
- } else {
- plc->quoted = param->parameter;
- }
- newbuffer_len += plc->quoted.size();
- }
- rewrite:
- /* allocate output buffer */
- out = String(newbuffer_len, ReserveString);
- newbuffer = out.bufferSlice().ptr;
- out.setSize(newbuffer_len);
- /* and build the query */
- plc = placeholders;
- ptr = in.data();
- do {
- t = plc->pos - ptr;
- if (t) {
- memcpy(newbuffer, ptr, t);
- newbuffer += t;
- }
- memcpy(newbuffer, plc->quoted.data(), plc->quoted.size());
- newbuffer += plc->quoted.size();
- ptr = plc->pos + plc->len;
- plc = plc->next;
- } while (plc);
- t = (in.data() + in.size()) - ptr;
- if (t) {
- memcpy(newbuffer, ptr, t);
- newbuffer += t;
- }
- *newbuffer = '\0';
- out = out.substr(0, newbuffer - out.data());
- ret = 1;
- goto clean_up;
- } else if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
- /* rewrite ? to :pdoX */
- StringBuffer idxbuf;
- const char *tmpl = stmt->named_rewrite_template ?
- stmt->named_rewrite_template : ":pdo%d";
- int bind_no = 1;
- newbuffer_len = in.size();
- for (plc = placeholders; plc; plc = plc->next) {
- int skip_map = 0;
- String name(plc->pos, plc->len, CopyString);
- /* check if bound parameter is already available */
- if (!strcmp(name.c_str(), "?") ||
- !stmt->bound_param_map.exists(name)) {
- idxbuf.printf(tmpl, bind_no++);
- } else {
- idxbuf.clear();
- idxbuf.append(stmt->bound_param_map[name].toString());
- skip_map = 1;
- }
- plc->quoted = idxbuf.detach();
- newbuffer_len += plc->quoted.size();
- if (!skip_map && stmt->named_rewrite_template) {
- /* create a mapping */
- stmt->bound_param_map.set(name, plc->quoted);
- }
- /* map number to name */
- stmt->bound_param_map.set(plc->bindno, plc->quoted);
- }
- goto rewrite;
- } else {
- /* rewrite :name to ? */
- newbuffer_len = in.size();
- for (plc = placeholders; plc; plc = plc->next) {
- String name(plc->pos, plc->len, CopyString);
- stmt->bound_param_map.set(plc->bindno, name);
- plc->quoted = "?";
- }
- goto rewrite;
- }
- clean_up:
- while (placeholders) {
- plc = placeholders;
- placeholders = plc->next;
- free(plc);
- }
- return ret;
- }
- ///////////////////////////////////////////////////////////////////////////////
- // PDOStatement
- c_PDOStatement::c_PDOStatement(Class* cb) :
- ExtObjectData(cb), m_rowIndex(-1) {
- }
- c_PDOStatement::~c_PDOStatement() {
- m_stmt.reset();
- m_row.reset();
- }
- void c_PDOStatement::sweep() {
- // No resources allocated outside HHVM's control
- }
- void c_PDOStatement::t___construct() {
- raise_error("You should not create a PDOStatement manually");
- }
- Variant c_PDOStatement::t_execute(CArrRef params /* = null_array */) {
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- if (!params.empty()) {
- m_stmt->bound_params.reset();
- for (ArrayIter iter(params); iter; ++iter) {
- SmartResource<PDOBoundParam> param(new PDOBoundParam);
- param->param_type = PDO_PARAM_STR;
- param->parameter = iter.second();
- param->stmt = NULL;
- if (iter.first().isString()) {
- param->name = iter.first();
- param->paramno = -1;
- } else {
- int64_t num_index = iter.first().toInt64();
- /* we're okay to be zero based here */
- if (num_index < 0) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "HY093", NULL);
- return false;
- }
- param->paramno = num_index;
- }
- if (!really_register_bound_param(param.get(), m_stmt, true)) {
- return false;
- }
- }
- }
- int ret = 1;
- if (PDO_PLACEHOLDER_NONE == m_stmt->supports_placeholders) {
- /* handle the emulated parameter binding, m_stmt->active_query_string
- holds the query with binds expanded and quoted. */
- ret = pdo_parse_params(m_stmt.get(), m_stmt->query_string,
- m_stmt->active_query_string);
- if (ret == 0) { /* no changes were made */
- m_stmt->active_query_string = m_stmt->query_string;
- } else if (ret == -1) {
- /* something broke */
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- } else if (!dispatch_param_event(m_stmt, PDO_PARAM_EVT_EXEC_PRE)) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- if (m_stmt->executer()) {
- m_stmt->active_query_string.reset();
- if (!m_stmt->executed) {
- /* this is the first execute */
- if (m_stmt->dbh->alloc_own_columns && m_stmt->columns.empty()) {
- /* for "big boy" drivers, we need to allocate memory to fetch
- * the results into, so lets do that now */
- ret = pdo_stmt_describe_columns(m_stmt);
- }
- m_stmt->executed = 1;
- }
- if (ret && !dispatch_param_event(m_stmt, PDO_PARAM_EVT_EXEC_POST)) {
- return false;
- }
- return (bool)ret;
- }
- m_stmt->active_query_string.reset();
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- Variant c_PDOStatement::t_fetch(int64_t how /* = 0 */,
- int64_t orientation /* = q_PDO$$FETCH_ORI_NEXT */,
- int64_t offset /* = 0 */) {
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- if (!pdo_stmt_verify_mode(m_stmt, how, false)) {
- return false;
- }
- Variant ret;
- if (!do_fetch(m_stmt, true, ret, (PDOFetchType)how,
- (PDOFetchOrientation)orientation, offset, NULL)) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- return ret;
- }
- Variant c_PDOStatement::t_fetchobject(const String& class_name /* = null_string */,
- CVarRef ctor_args /* = null */) {
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- if (!pdo_stmt_verify_mode(m_stmt, PDO_FETCH_CLASS, false)) {
- return false;
- }
- String old_clsname = m_stmt->fetch.clsname;
- Variant old_ctor_args = m_stmt->fetch.ctor_args;
- bool error = false;
- m_stmt->fetch.clsname = class_name;
- if (class_name.isNull()) {
- m_stmt->fetch.clsname = "stdclass";
- }
- if (!f_class_exists(m_stmt->fetch.clsname)) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "HY000",
- "Could not find user-supplied class");
- error = true;
- }
- if (!ctor_args.isNull() && !ctor_args.isArray()) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "HY000",
- "ctor_args must be either NULL or an array");
- error = true;
- }
- m_stmt->fetch.ctor_args = ctor_args;
- Variant ret;
- if (!error && !do_fetch(m_stmt, true, ret, PDO_FETCH_CLASS,
- PDO_FETCH_ORI_NEXT, 0, NULL)) {
- error = true;
- }
- if (error) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- }
- m_stmt->fetch.clsname = old_clsname;
- m_stmt->fetch.ctor_args = old_ctor_args;
- if (error) {
- return false;
- }
- return ret;
- }
- Variant c_PDOStatement::t_fetchcolumn(int64_t column_numner /* = 0 */) {
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- if (!do_fetch_common(m_stmt, PDO_FETCH_ORI_NEXT, 0, true)) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- Variant ret;
- fetch_value(m_stmt, ret, column_numner, NULL);
- return ret;
- }
- Variant c_PDOStatement::t_fetchall(int64_t how /* = 0 */,
- CVarRef class_name /* = null */,
- CVarRef ctor_args /* = null */) {
- if (!pdo_stmt_verify_mode(m_stmt, how, true)) {
- return false;
- }
- String old_clsname = m_stmt->fetch.clsname;
- Variant old_ctor_args = m_stmt->fetch.ctor_args;
- int error = 0;
- switch (how & ~PDO_FETCH_FLAGS) {
- case PDO_FETCH_CLASS:
- m_stmt->fetch.clsname = class_name;
- if (class_name.isNull()) {
- m_stmt->fetch.clsname = "stdclass";
- }
- if (!f_class_exists(m_stmt->fetch.clsname)) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "HY000",
- "Could not find user-supplied class");
- error = 1;
- }
- if (!ctor_args.isNull() && !ctor_args.isArray()) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "HY000",
- "ctor_args must be either NULL or an array");
- error = 1;
- break;
- }
- m_stmt->fetch.ctor_args = ctor_args;
- if (!error) {
- do_fetch_class_prepare(m_stmt);
- }
- break;
- case PDO_FETCH_FUNC:
- if (!f_function_exists(class_name.toString())) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "HY000",
- "no fetch function specified");
- error = 1;
- } else {
- m_stmt->fetch.func = class_name;
- do_fetch_func_prepare(m_stmt);
- }
- break;
- case PDO_FETCH_COLUMN:
- if (class_name.isNull()) {
- m_stmt->fetch.column = how & PDO_FETCH_GROUP ? -1 : 0;
- } else {
- m_stmt->fetch.column = class_name.toInt64();
- }
- if (!ctor_args.isNull()) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "HY000",
- "Third parameter not allowed for "
- "PDO::FETCH_COLUMN");
- error = 1;
- }
- break;
- }
- int flags = how & PDO_FETCH_FLAGS;
- if ((how & ~PDO_FETCH_FLAGS) == PDO_FETCH_USE_DEFAULT) {
- flags |= m_stmt->default_fetch_type & PDO_FETCH_FLAGS;
- how |= m_stmt->default_fetch_type & ~PDO_FETCH_FLAGS;
- }
- Variant *return_all = NULL;
- Variant return_value;
- Variant data;
- if (!error) {
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- if ((how & PDO_FETCH_GROUP) || how == PDO_FETCH_KEY_PAIR ||
- (how == PDO_FETCH_USE_DEFAULT &&
- m_stmt->default_fetch_type == PDO_FETCH_KEY_PAIR)) {
- return_value = Array::Create();
- return_all = &return_value;
- }
- if (!do_fetch(m_stmt, true, data, (PDOFetchType)(how | flags),
- PDO_FETCH_ORI_NEXT, 0, return_all)) {
- error = 2;
- }
- }
- if (!error) {
- if ((how & PDO_FETCH_GROUP)) {
- do {
- data.reset();
- } while (do_fetch(m_stmt, true, data, (PDOFetchType)(how | flags),
- PDO_FETCH_ORI_NEXT, 0, return_all));
- } else if (how == PDO_FETCH_KEY_PAIR ||
- (how == PDO_FETCH_USE_DEFAULT &&
- m_stmt->default_fetch_type == PDO_FETCH_KEY_PAIR)) {
- while (do_fetch(m_stmt, true, data, (PDOFetchType)(how | flags),
- PDO_FETCH_ORI_NEXT, 0, return_all));
- } else {
- return_value = Array::Create();
- do {
- return_value.append(data);
- data.reset();
- } while (do_fetch(m_stmt, true, data, (PDOFetchType)(how | flags),
- PDO_FETCH_ORI_NEXT, 0, NULL));
- }
- }
- m_stmt->fetch.clsname = old_clsname;
- m_stmt->fetch.ctor_args = old_ctor_args;
- if (error) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- if (error != 2) {
- return false;
- }
- /* on no results, return an empty array */
- if (!return_value.isArray()) {
- return_value = Array::Create();
- }
- }
- return return_value;
- }
- bool c_PDOStatement::t_bindvalue(CVarRef paramno, CVarRef param,
- int64_t type /* = q_PDO$$PARAM_STR */) {
- return register_bound_param(paramno, param, type, 0, uninit_null(), m_stmt, true);
- }
- bool c_PDOStatement::t_bindparam(CVarRef paramno, VRefParam param,
- int64_t type /* = q_PDO$$PARAM_STR */,
- int64_t max_value_len /* = 0 */,
- CVarRef driver_params /*= null */) {
- return register_bound_param(paramno, ref(param), type, max_value_len,
- driver_params, m_stmt, true);
- }
- bool c_PDOStatement::t_bindcolumn(CVarRef paramno, VRefParam param,
- int64_t type /* = q_PDO$$PARAM_STR */,
- int64_t max_value_len /* = 0 */,
- CVarRef driver_params /* = null */) {
- return register_bound_param(paramno, ref(param), type, max_value_len,
- driver_params, m_stmt, false);
- }
- int64_t c_PDOStatement::t_rowcount() {
- return m_stmt->row_count;
- }
- Variant c_PDOStatement::t_errorcode() {
- if (m_stmt->error_code[0] == '\0') {
- return uninit_null();
- }
- return String(m_stmt->error_code, CopyString);
- }
- Array c_PDOStatement::t_errorinfo() {
- Array ret;
- ret.append(String(m_stmt->error_code, CopyString));
- if (m_stmt->dbh->support(PDOConnection::MethodFetchErr)) {
- m_stmt->dbh->fetchErr(m_stmt.get(), ret);
- }
- int error_count = ret.size();
- int error_expected_count = 3;
- if (error_expected_count > error_count) {
- int error_count_diff = error_expected_count - error_count;
- for (int i = 0; i < error_count_diff; i++) {
- ret.append(uninit_null());
- }
- }
- return ret;
- }
- Variant c_PDOStatement::t_setattribute(int64_t attribute, CVarRef value) {
- if (!m_stmt->support(PDOStatement::MethodSetAttribute)) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "IM001",
- "This driver doesn't support setting attributes");
- return false;
- }
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- if (m_stmt->setAttribute(attribute, value)) {
- return true;
- }
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- Variant c_PDOStatement::t_getattribute(int64_t attribute) {
- Variant ret;
- if (!m_stmt->support(PDOStatement::MethodGetAttribute)) {
- if (!generic_stmt_attr_get(m_stmt, ret, attribute)) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "IM001",
- "This driver doesn't support getting attributes");
- return false;
- }
- return ret;
- }
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- switch (m_stmt->getAttribute(attribute, ret)) {
- case -1:
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- case 0:
- if (!generic_stmt_attr_get(m_stmt, ret, attribute)) {
- /* XXX: should do something better here */
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "IM001",
- "driver doesn't support getting that attribute");
- return false;
- }
- break;
- default:
- break;
- }
- return ret;
- }
- int64_t c_PDOStatement::t_columncount() {
- return m_stmt->column_count;
- }
- const StaticString
- s_name("name"),
- s_len("len"),
- s_precision("precision"),
- s_pdo_type("pdo_type");
- Variant c_PDOStatement::t_getcolumnmeta(int64_t column) {
- if (column < 0) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "42P10",
- "column number must be non-negative");
- return false;
- }
- if (!m_stmt->support(PDOStatement::MethodGetColumnMeta)) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "IM001",
- "driver doesn't support meta data");
- return false;
- }
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- Array ret;
- if (!m_stmt->getColumnMeta(column, ret)) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- /* add stock items */
- PDOColumn *col = m_stmt->columns[column].toResource().getTyped<PDOColumn>();
- ret.set(s_name, col->name);
- ret.set(s_len, (int64_t)col->maxlen); /* FIXME: unsigned ? */
- ret.set(s_precision, (int64_t)col->precision);
- if (col->param_type != PDO_PARAM_ZVAL) {
- // if param_type is PDO_PARAM_ZVAL the driver has to provide correct data
- ret.set(s_pdo_type, (int64_t)col->param_type);
- }
- return ret;
- }
- bool c_PDOStatement::t_setfetchmode(int _argc, int64_t mode,
- CArrRef _argv /* = null_array */) {
- return pdo_stmt_set_fetch_mode(m_stmt, _argc, mode, _argv);
- }
- bool c_PDOStatement::t_nextrowset() {
- if (!m_stmt->support(PDOStatement::MethodNextRowset)) {
- pdo_raise_impl_error(m_stmt->dbh, m_stmt, "IM001",
- "driver does not support multiple rowsets");
- return false;
- }
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- /* un-describe */
- if (!m_stmt->columns.empty()) {
- m_stmt->columns.clear();
- m_stmt->column_count = 0;
- }
- if (!m_stmt->nextRowset()) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- pdo_stmt_describe_columns(m_stmt);
- return true;
- }
- bool c_PDOStatement::t_closecursor() {
- if (!m_stmt->support(PDOStatement::MethodCursorCloser)) {
- /* emulate it by fetching and discarding rows */
- do {
- while (m_stmt->fetcher(PDO_FETCH_ORI_NEXT, 0));
- if (!t_nextrowset()) {
- break;
- }
- } while (true);
- m_stmt->executed = 0;
- return true;
- }
- strcpy(m_stmt->error_code, PDO_ERR_NONE);
- if (!m_stmt->cursorCloser()) {
- PDO_HANDLE_STMT_ERR(m_stmt);
- return false;
- }
- m_stmt->executed = 0;
- return true;
- }
- Variant c_PDOStatement::t_debugdumpparams() {
- Variant fobj = File::Open("php://output", "w");
- if (same(fobj, false)) {
- return false;
- }
- File *f = fobj.toResource().getTyped<File>();
- Array params;
- params.append(m_stmt->query_string.size());
- params.append(m_stmt->query_string.size());
- params.append(m_stmt->query_string.data());
- f->printf("SQL: [%d] %.*s\n", params);
- f->printf("Params: %d\n", make_packed_array(m_stmt->bound_params.size()));
- for (ArrayIter iter(m_stmt->bound_params); iter; ++iter) {
- if (iter.first().isString()) {
- String key = iter.first().toString();
- params = make_packed_array(key.size(), key.size(), key.data());
- f->printf("Key: Name: [%d] %.*s\n", params);
- } else {
- f->printf("Key: Position #%ld:\n",
- make_packed_array(iter.first().toInt64()));
- }
- PDOBoundParam *param = iter.second().toResource().getTyped<PDOBoundParam>();
- params.clear();
- params.append(param->paramno);
- params.append(param->name.size());
- params.append(param->name.size());
- params.append(param->name.data());
- params.append(param->is_param);
- params.append(param->param_type);
- f->printf("paramno=%d\nname=[%d] \"%.*s\"\nis_param=%d\nparam_type=%d\n",
- params);
- }
- return true;
- }
- Variant c_PDOStatement::t_current() {
- return m_row;
- }
- Variant c_PDOStatement::t_key() {
- return m_rowIndex;
- }
- Variant c_PDOStatement::t_next() {
- m_row = t_fetch(PDO_FETCH_USE_DEFAULT);
- if (same(m_row, false)) {
- m_rowIndex = -1;
- } else {
- ++m_rowIndex;
- }
- return uninit_null();
- }
- Variant c_PDOStatement::t_rewind() {
- m_rowIndex = -1;
- t_next();
- return uninit_null();
- }
- Variant c_PDOStatement::t_valid() {
- return m_rowIndex >= 0;
- }
- Variant c_PDOStatement::t___wakeup() {
- throw_pdo_exception(uninit_null(), uninit_null(), "You cannot serialize or unserialize "
- "PDOStatement instances");
- return uninit_null();
- }
- Variant c_PDOStatement::t___sleep() {
- throw_pdo_exception(uninit_null(), uninit_null(), "You cannot serialize or unserialize "
- "PDOStatement instances");
- return uninit_null();
- }
- ///////////////////////////////////////////////////////////////////////////////
- }