PK P=Voi oi adodb-active-record.inc.phpnu W+A _dbat
$_ADODB_ACTIVE_DBS = array();
$ACTIVE_RECORD_SAFETY = true;
$ADODB_ACTIVE_DEFVALS = false;
$ADODB_ACTIVE_CACHESECS = 0;
class ADODB_Active_DB {
var $db; // ADOConnection
var $tables; // assoc array of ADODB_Active_Table objects, indexed by tablename
}
class ADODB_Active_Table {
var $name; // table name
var $flds; // assoc array of adofieldobjs, indexed by fieldname
var $keys; // assoc array of primary keys, indexed by fieldname
var $_created; // only used when stored as a cached file
var $_belongsTo = array();
var $_hasMany = array();
}
// $db = database connection
// $index = name of index - can be associative, for an example see
// http://phplens.com/lens/lensforum/msgs.php?id=17790
// returns index into $_ADODB_ACTIVE_DBS
function ADODB_SetDatabaseAdapter(&$db, $index=false)
{
global $_ADODB_ACTIVE_DBS;
foreach($_ADODB_ACTIVE_DBS as $k => $d) {
if (PHP_VERSION >= 5) {
if ($d->db === $db) {
return $k;
}
} else {
if ($d->db->_connectionID === $db->_connectionID && $db->database == $d->db->database) {
return $k;
}
}
}
$obj = new ADODB_Active_DB();
$obj->db = $db;
$obj->tables = array();
if ($index == false) {
$index = sizeof($_ADODB_ACTIVE_DBS);
}
$_ADODB_ACTIVE_DBS[$index] = $obj;
return sizeof($_ADODB_ACTIVE_DBS)-1;
}
class ADODB_Active_Record {
static $_changeNames = true; // dynamically pluralize table names
static $_quoteNames = false;
static $_foreignSuffix = '_id'; //
var $_dbat; // associative index pointing to ADODB_Active_DB eg. $ADODB_Active_DBS[_dbat]
var $_table; // tablename, if set in class definition then use it as table name
var $_tableat; // associative index pointing to ADODB_Active_Table, eg $ADODB_Active_DBS[_dbat]->tables[$this->_tableat]
var $_where; // where clause set in Load()
var $_saved = false; // indicates whether data is already inserted.
var $_lasterr = false; // last error message
var $_original = false; // the original values loaded or inserted, refreshed on update
var $foreignName; // CFR: class name when in a relationship
var $lockMode = ' for update '; // you might want to change to
static function UseDefaultValues($bool=null)
{
global $ADODB_ACTIVE_DEFVALS;
if (isset($bool)) {
$ADODB_ACTIVE_DEFVALS = $bool;
}
return $ADODB_ACTIVE_DEFVALS;
}
// should be static
static function SetDatabaseAdapter(&$db, $index=false)
{
return ADODB_SetDatabaseAdapter($db, $index);
}
public function __set($name, $value)
{
$name = str_replace(' ', '_', $name);
$this->$name = $value;
}
// php5 constructor
function __construct($table = false, $pkeyarr=false, $db=false)
{
global $_ADODB_ACTIVE_DBS;
if ($db == false && is_object($pkeyarr)) {
$db = $pkeyarr;
$pkeyarr = false;
}
if (!$table) {
if (!empty($this->_table)) {
$table = $this->_table;
}
else $table = $this->_pluralize(get_class($this));
}
$this->foreignName = strtolower(get_class($this)); // CFR: default foreign name
if ($db) {
$this->_dbat = ADODB_Active_Record::SetDatabaseAdapter($db);
} else if (!isset($this->_dbat)) {
if (sizeof($_ADODB_ACTIVE_DBS) == 0) {
$this->Error(
"No database connection set; use ADOdb_Active_Record::SetDatabaseAdapter(\$db)",
'ADODB_Active_Record::__constructor'
);
}
end($_ADODB_ACTIVE_DBS);
$this->_dbat = key($_ADODB_ACTIVE_DBS);
}
$this->_table = $table;
$this->_tableat = $table; # reserved for setting the assoc value to a non-table name, eg. the sql string in future
$this->UpdateActiveTable($pkeyarr);
}
function __wakeup()
{
$class = get_class($this);
new $class;
}
function _pluralize($table)
{
if (!ADODB_Active_Record::$_changeNames) {
return $table;
}
$ut = strtoupper($table);
$len = strlen($table);
$lastc = $ut[$len-1];
$lastc2 = substr($ut,$len-2);
switch ($lastc) {
case 'S':
return $table.'es';
case 'Y':
return substr($table,0,$len-1).'ies';
case 'X':
return $table.'es';
case 'H':
if ($lastc2 == 'CH' || $lastc2 == 'SH') {
return $table.'es';
}
default:
return $table.'s';
}
}
// CFR Lamest singular inflector ever - @todo Make it real!
// Note: There is an assumption here...and it is that the argument's length >= 4
function _singularize($tables)
{
if (!ADODB_Active_Record::$_changeNames) {
return $table;
}
$ut = strtoupper($tables);
$len = strlen($tables);
if($ut[$len-1] != 'S') {
return $tables; // I know...forget oxen
}
if($ut[$len-2] != 'E') {
return substr($tables, 0, $len-1);
}
switch($ut[$len-3]) {
case 'S':
case 'X':
return substr($tables, 0, $len-2);
case 'I':
return substr($tables, 0, $len-3) . 'y';
case 'H';
if($ut[$len-4] == 'C' || $ut[$len-4] == 'S') {
return substr($tables, 0, $len-2);
}
default:
return substr($tables, 0, $len-1); // ?
}
}
function hasMany($foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
{
$ar = new $foreignClass($foreignRef);
$ar->foreignName = $foreignRef;
$ar->UpdateActiveTable();
$ar->foreignKey = ($foreignKey) ? $foreignKey : $foreignRef.ADODB_Active_Record::$_foreignSuffix;
$table =& $this->TableInfo();
$table->_hasMany[$foreignRef] = $ar;
# $this->$foreignRef = $this->_hasMany[$foreignRef]; // WATCHME Removed assignment by ref. to please __get()
}
// use when you don't want ADOdb to auto-pluralize tablename
static function TableHasMany($table, $foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
{
$ar = new ADODB_Active_Record($table);
$ar->hasMany($foreignRef, $foreignKey, $foreignClass);
}
// use when you don't want ADOdb to auto-pluralize tablename
static function TableKeyHasMany($table, $tablePKey, $foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
{
if (!is_array($tablePKey)) {
$tablePKey = array($tablePKey);
}
$ar = new ADODB_Active_Record($table,$tablePKey);
$ar->hasMany($foreignRef, $foreignKey, $foreignClass);
}
// use when you want ADOdb to auto-pluralize tablename for you. Note that the class must already be defined.
// e.g. class Person will generate relationship for table Persons
static function ClassHasMany($parentclass, $foreignRef, $foreignKey = false, $foreignClass = 'ADODB_Active_Record')
{
$ar = new $parentclass();
$ar->hasMany($foreignRef, $foreignKey, $foreignClass);
}
function belongsTo($foreignRef,$foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
{
global $inflector;
$ar = new $parentClass($this->_pluralize($foreignRef));
$ar->foreignName = $foreignRef;
$ar->parentKey = $parentKey;
$ar->UpdateActiveTable();
$ar->foreignKey = ($foreignKey) ? $foreignKey : $foreignRef.ADODB_Active_Record::$_foreignSuffix;
$table =& $this->TableInfo();
$table->_belongsTo[$foreignRef] = $ar;
# $this->$foreignRef = $this->_belongsTo[$foreignRef];
}
static function ClassBelongsTo($class, $foreignRef, $foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
{
$ar = new $class();
$ar->belongsTo($foreignRef, $foreignKey, $parentKey, $parentClass);
}
static function TableBelongsTo($table, $foreignRef, $foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
{
$ar = new ADOdb_Active_Record($table);
$ar->belongsTo($foreignRef, $foreignKey, $parentKey, $parentClass);
}
static function TableKeyBelongsTo($table, $tablePKey, $foreignRef, $foreignKey=false, $parentKey='', $parentClass = 'ADODB_Active_Record')
{
if (!is_array($tablePKey)) {
$tablePKey = array($tablePKey);
}
$ar = new ADOdb_Active_Record($table, $tablePKey);
$ar->belongsTo($foreignRef, $foreignKey, $parentKey, $parentClass);
}
/**
* __get Access properties - used for lazy loading
*
* @param mixed $name
* @access protected
* @return mixed
*/
function __get($name)
{
return $this->LoadRelations($name, '', -1, -1);
}
/**
* @param string $name
* @param string $whereOrderBy : eg. ' AND field1 = value ORDER BY field2'
* @param offset
* @param limit
* @return mixed
*/
function LoadRelations($name, $whereOrderBy='', $offset=-1,$limit=-1)
{
$extras = array();
$table = $this->TableInfo();
if ($limit >= 0) {
$extras['limit'] = $limit;
}
if ($offset >= 0) {
$extras['offset'] = $offset;
}
if (strlen($whereOrderBy)) {
if (!preg_match('/^[ \n\r]*AND/i', $whereOrderBy)) {
if (!preg_match('/^[ \n\r]*ORDER[ \n\r]/i', $whereOrderBy)) {
$whereOrderBy = 'AND ' . $whereOrderBy;
}
}
}
if(!empty($table->_belongsTo[$name])) {
$obj = $table->_belongsTo[$name];
$columnName = $obj->foreignKey;
if(empty($this->$columnName)) {
$this->$name = null;
}
else {
if ($obj->parentKey) {
$key = $obj->parentKey;
}
else {
$key = reset($table->keys);
}
$arrayOfOne = $obj->Find($key.'='.$this->$columnName.' '.$whereOrderBy,false,false,$extras);
if ($arrayOfOne) {
$this->$name = $arrayOfOne[0];
return $arrayOfOne[0];
}
}
}
if(!empty($table->_hasMany[$name])) {
$obj = $table->_hasMany[$name];
$key = reset($table->keys);
$id = @$this->$key;
if (!is_numeric($id)) {
$db = $this->DB();
$id = $db->qstr($id);
}
$objs = $obj->Find($obj->foreignKey.'='.$id. ' '.$whereOrderBy,false,false,$extras);
if (!$objs) {
$objs = array();
}
$this->$name = $objs;
return $objs;
}
return array();
}
//////////////////////////////////
// update metadata
function UpdateActiveTable($pkeys=false,$forceUpdate=false)
{
global $_ADODB_ACTIVE_DBS , $ADODB_CACHE_DIR, $ADODB_ACTIVE_CACHESECS;
global $ADODB_ACTIVE_DEFVALS,$ADODB_FETCH_MODE;
$activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
$table = $this->_table;
$tables = $activedb->tables;
$tableat = $this->_tableat;
if (!$forceUpdate && !empty($tables[$tableat])) {
$acttab = $tables[$tableat];
foreach($acttab->flds as $name => $fld) {
if ($ADODB_ACTIVE_DEFVALS && isset($fld->default_value)) {
$this->$name = $fld->default_value;
}
else {
$this->$name = null;
}
}
return;
}
$db = $activedb->db;
$fname = $ADODB_CACHE_DIR . '/adodb_' . $db->databaseType . '_active_'. $table . '.cache';
if (!$forceUpdate && $ADODB_ACTIVE_CACHESECS && $ADODB_CACHE_DIR && file_exists($fname)) {
$fp = fopen($fname,'r');
@flock($fp, LOCK_SH);
$acttab = unserialize(fread($fp,100000));
fclose($fp);
if ($acttab->_created + $ADODB_ACTIVE_CACHESECS - (abs(rand()) % 16) > time()) {
// abs(rand()) randomizes deletion, reducing contention to delete/refresh file
// ideally, you should cache at least 32 secs
foreach($acttab->flds as $name => $fld) {
if ($ADODB_ACTIVE_DEFVALS && isset($fld->default_value)) {
$this->$name = $fld->default_value;
}
else {
$this->$name = null;
}
}
$activedb->tables[$table] = $acttab;
//if ($db->debug) ADOConnection::outp("Reading cached active record file: $fname");
return;
} else if ($db->debug) {
ADOConnection::outp("Refreshing cached active record file: $fname");
}
}
$activetab = new ADODB_Active_Table();
$activetab->name = $table;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
if ($db->fetchMode !== false) {
$savem = $db->SetFetchMode(false);
}
$cols = $db->MetaColumns($table);
if (isset($savem)) {
$db->SetFetchMode($savem);
}
$ADODB_FETCH_MODE = $save;
if (!$cols) {
$this->Error("Invalid table name: $table",'UpdateActiveTable');
return false;
}
$fld = reset($cols);
if (!$pkeys) {
if (isset($fld->primary_key)) {
$pkeys = array();
foreach($cols as $name => $fld) {
if (!empty($fld->primary_key)) {
$pkeys[] = $name;
}
}
} else
$pkeys = $this->GetPrimaryKeys($db, $table);
}
if (empty($pkeys)) {
$this->Error("No primary key found for table $table",'UpdateActiveTable');
return false;
}
$attr = array();
$keys = array();
switch (ADODB_ASSOC_CASE) {
case ADODB_ASSOC_CASE_LOWER:
foreach($cols as $name => $fldobj) {
$name = strtolower($name);
if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value)) {
$this->$name = $fldobj->default_value;
}
else {
$this->$name = null;
}
$attr[$name] = $fldobj;
}
foreach($pkeys as $k => $name) {
$keys[strtolower($name)] = strtolower($name);
}
break;
case ADODB_ASSOC_CASE_UPPER:
foreach($cols as $name => $fldobj) {
$name = strtoupper($name);
if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value)) {
$this->$name = $fldobj->default_value;
}
else {
$this->$name = null;
}
$attr[$name] = $fldobj;
}
foreach($pkeys as $k => $name) {
$keys[strtoupper($name)] = strtoupper($name);
}
break;
default:
foreach($cols as $name => $fldobj) {
$name = ($fldobj->name);
if ($ADODB_ACTIVE_DEFVALS && isset($fldobj->default_value)) {
$this->$name = $fldobj->default_value;
}
else {
$this->$name = null;
}
$attr[$name] = $fldobj;
}
foreach($pkeys as $k => $name) {
$keys[$name] = $cols[strtoupper($name)]->name;
}
break;
}
$activetab->keys = $keys;
$activetab->flds = $attr;
if ($ADODB_ACTIVE_CACHESECS && $ADODB_CACHE_DIR) {
$activetab->_created = time();
$s = serialize($activetab);
if (!function_exists('adodb_write_file')) {
include(ADODB_DIR.'/adodb-csvlib.inc.php');
}
adodb_write_file($fname,$s);
}
if (isset($activedb->tables[$table])) {
$oldtab = $activedb->tables[$table];
if ($oldtab) {
$activetab->_belongsTo = $oldtab->_belongsTo;
$activetab->_hasMany = $oldtab->_hasMany;
}
}
$activedb->tables[$table] = $activetab;
}
function GetPrimaryKeys(&$db, $table)
{
return $db->MetaPrimaryKeys($table);
}
// error handler for both PHP4+5.
function Error($err,$fn)
{
global $_ADODB_ACTIVE_DBS;
$fn = get_class($this).'::'.$fn;
$this->_lasterr = $fn.': '.$err;
if ($this->_dbat < 0) {
$db = false;
}
else {
$activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
$db = $activedb->db;
}
if (function_exists('adodb_throw')) {
if (!$db) {
adodb_throw('ADOdb_Active_Record', $fn, -1, $err, 0, 0, false);
}
else {
adodb_throw($db->databaseType, $fn, -1, $err, 0, 0, $db);
}
} else {
if (!$db || $db->debug) {
ADOConnection::outp($this->_lasterr);
}
}
}
// return last error message
function ErrorMsg()
{
if (!function_exists('adodb_throw')) {
if ($this->_dbat < 0) {
$db = false;
}
else {
$db = $this->DB();
}
// last error could be database error too
if ($db && $db->ErrorMsg()) {
return $db->ErrorMsg();
}
}
return $this->_lasterr;
}
function ErrorNo()
{
if ($this->_dbat < 0) {
return -9999; // no database connection...
}
$db = $this->DB();
return (int) $db->ErrorNo();
}
// retrieve ADOConnection from _ADODB_Active_DBs
function DB()
{
global $_ADODB_ACTIVE_DBS;
if ($this->_dbat < 0) {
$false = false;
$this->Error("No database connection set: use ADOdb_Active_Record::SetDatabaseAdaptor(\$db)", "DB");
return $false;
}
$activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
$db = $activedb->db;
return $db;
}
// retrieve ADODB_Active_Table
function &TableInfo()
{
global $_ADODB_ACTIVE_DBS;
$activedb = $_ADODB_ACTIVE_DBS[$this->_dbat];
$table = $activedb->tables[$this->_tableat];
return $table;
}
// I have an ON INSERT trigger on a table that sets other columns in the table.
// So, I find that for myTable, I want to reload an active record after saving it. -- Malcolm Cook
function Reload()
{
$db = $this->DB();
if (!$db) {
return false;
}
$table = $this->TableInfo();
$where = $this->GenWhere($db, $table);
return($this->Load($where));
}
// set a numeric array (using natural table field ordering) as object properties
function Set(&$row)
{
global $ACTIVE_RECORD_SAFETY;
$db = $this->DB();
if (!$row) {
$this->_saved = false;
return false;
}
$this->_saved = true;
$table = $this->TableInfo();
if ($ACTIVE_RECORD_SAFETY && sizeof($table->flds) != sizeof($row)) {
#
$bad_size = TRUE;
if (sizeof($row) == 2 * sizeof($table->flds)) {
// Only keep string keys
$keys = array_filter(array_keys($row), 'is_string');
if (sizeof($keys) == sizeof($table->flds)) {
$bad_size = FALSE;
}
}
if ($bad_size) {
$this->Error("Table structure of $this->_table has changed","Load");
return false;
}
#
}
else
$keys = array_keys($row);
#
reset($keys);
$this->_original = array();
foreach($table->flds as $name=>$fld) {
$value = $row[current($keys)];
$this->$name = $value;
$this->_original[] = $value;
next($keys);
}
#
return true;
}
// get last inserted id for INSERT
function LastInsertID(&$db,$fieldname)
{
if ($db->hasInsertID) {
$val = $db->Insert_ID($this->_table,$fieldname);
}
else {
$val = false;
}
if (is_null($val) || $val === false) {
// this might not work reliably in multi-user environment
return $db->GetOne("select max(".$fieldname.") from ".$this->_table);
}
return $val;
}
// quote data in where clause
function doquote(&$db, $val,$t)
{
switch($t) {
case 'L':
if (strpos($db->databaseType,'postgres') !== false) {
return $db->qstr($val);
}
case 'D':
case 'T':
if (empty($val)) {
return 'null';
}
case 'B':
case 'N':
case 'C':
case 'X':
if (is_null($val)) {
return 'null';
}
if (strlen($val)>0 &&
(strncmp($val,"'",1) != 0 || substr($val,strlen($val)-1,1) != "'")
) {
return $db->qstr($val);
break;
}
default:
return $val;
break;
}
}
// generate where clause for an UPDATE/SELECT
function GenWhere(&$db, &$table)
{
$keys = $table->keys;
$parr = array();
foreach($keys as $k) {
$f = $table->flds[$k];
if ($f) {
$parr[] = $k.' = '.$this->doquote($db,$this->$k,$db->MetaType($f->type));
}
}
return implode(' and ', $parr);
}
function _QName($n,$db=false)
{
if (!ADODB_Active_Record::$_quoteNames) {
return $n;
}
if (!$db) {
$db = $this->DB();
if (!$db) {
return false;
}
}
return $db->nameQuote.$n.$db->nameQuote;
}
//------------------------------------------------------------ Public functions below
function Load($where=null,$bindarr=false, $lock = false)
{
global $ADODB_FETCH_MODE;
$db = $this->DB();
if (!$db) {
return false;
}
$this->_where = $where;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($db->fetchMode !== false) {
$savem = $db->SetFetchMode(false);
}
$qry = "select * from ".$this->_table;
if($where) {
$qry .= ' WHERE '.$where;
}
if ($lock) {
$qry .= $this->lockMode;
}
$row = $db->GetRow($qry,$bindarr);
if (isset($savem)) {
$db->SetFetchMode($savem);
}
$ADODB_FETCH_MODE = $save;
return $this->Set($row);
}
function LoadLocked($where=null, $bindarr=false)
{
$this->Load($where,$bindarr,true);
}
# useful for multiple record inserts
# see http://phplens.com/lens/lensforum/msgs.php?id=17795
function Reset()
{
$this->_where=null;
$this->_saved = false;
$this->_lasterr = false;
$this->_original = false;
$vars=get_object_vars($this);
foreach($vars as $k=>$v){
if(substr($k,0,1)!=='_'){
$this->{$k}=null;
}
}
$this->foreignName=strtolower(get_class($this));
return true;
}
// false on error
function Save()
{
if ($this->_saved) {
$ok = $this->Update();
}
else {
$ok = $this->Insert();
}
return $ok;
}
// false on error
function Insert()
{
$db = $this->DB();
if (!$db) {
return false;
}
$cnt = 0;
$table = $this->TableInfo();
$valarr = array();
$names = array();
$valstr = array();
foreach($table->flds as $name=>$fld) {
$val = $this->$name;
if(!is_array($val) || !is_null($val) || !array_key_exists($name, $table->keys)) {
$valarr[] = $val;
$names[] = $this->_QName($name,$db);
$valstr[] = $db->Param($cnt);
$cnt += 1;
}
}
if (empty($names)){
foreach($table->flds as $name=>$fld) {
$valarr[] = null;
$names[] = $name;
$valstr[] = $db->Param($cnt);
$cnt += 1;
}
}
$sql = 'INSERT INTO '.$this->_table."(".implode(',',$names).') VALUES ('.implode(',',$valstr).')';
$ok = $db->Execute($sql,$valarr);
if ($ok) {
$this->_saved = true;
$autoinc = false;
foreach($table->keys as $k) {
if (is_null($this->$k)) {
$autoinc = true;
break;
}
}
if ($autoinc && sizeof($table->keys) == 1) {
$k = reset($table->keys);
$this->$k = $this->LastInsertID($db,$k);
}
}
$this->_original = $valarr;
return !empty($ok);
}
function Delete()
{
$db = $this->DB();
if (!$db) {
return false;
}
$table = $this->TableInfo();
$where = $this->GenWhere($db,$table);
$sql = 'DELETE FROM '.$this->_table.' WHERE '.$where;
$ok = $db->Execute($sql);
return $ok ? true : false;
}
// returns an array of active record objects
function Find($whereOrderBy,$bindarr=false,$pkeysArr=false,$extra=array())
{
$db = $this->DB();
if (!$db || empty($this->_table)) {
return false;
}
$arr = $db->GetActiveRecordsClass(get_class($this),$this->_table, $whereOrderBy,$bindarr,$pkeysArr,$extra);
return $arr;
}
// returns 0 on error, 1 on update, 2 on insert
function Replace()
{
$db = $this->DB();
if (!$db) {
return false;
}
$table = $this->TableInfo();
$pkey = $table->keys;
foreach($table->flds as $name=>$fld) {
$val = $this->$name;
/*
if (is_null($val)) {
if (isset($fld->not_null) && $fld->not_null) {
if (isset($fld->default_value) && strlen($fld->default_value)) {
continue;
}
else {
$this->Error("Cannot update null into $name","Replace");
return false;
}
}
}*/
if (is_null($val) && !empty($fld->auto_increment)) {
continue;
}
if (is_array($val)) {
continue;
}
$t = $db->MetaType($fld->type);
$arr[$name] = $this->doquote($db,$val,$t);
$valarr[] = $val;
}
if (!is_array($pkey)) {
$pkey = array($pkey);
}
switch (ADODB_ASSOC_CASE) {
case ADODB_ASSOC_CASE_LOWER:
foreach ($pkey as $k => $v) {
$pkey[$k] = strtolower($v);
}
break;
case ADODB_ASSOC_CASE_UPPER:
foreach ($pkey as $k => $v) {
$pkey[$k] = strtoupper($v);
}
break;
}
$ok = $db->Replace($this->_table,$arr,$pkey);
if ($ok) {
$this->_saved = true; // 1= update 2=insert
if ($ok == 2) {
$autoinc = false;
foreach($table->keys as $k) {
if (is_null($this->$k)) {
$autoinc = true;
break;
}
}
if ($autoinc && sizeof($table->keys) == 1) {
$k = reset($table->keys);
$this->$k = $this->LastInsertID($db,$k);
}
}
$this->_original = $valarr;
}
return $ok;
}
// returns 0 on error, 1 on update, -1 if no change in data (no update)
function Update()
{
$db = $this->DB();
if (!$db) {
return false;
}
$table = $this->TableInfo();
$where = $this->GenWhere($db, $table);
if (!$where) {
$this->error("Where missing for table $table", "Update");
return false;
}
$valarr = array();
$neworig = array();
$pairs = array();
$i = -1;
$cnt = 0;
foreach($table->flds as $name=>$fld) {
$i += 1;
$val = $this->$name;
$neworig[] = $val;
if (isset($table->keys[$name]) || is_array($val)) {
continue;
}
if (is_null($val)) {
if (isset($fld->not_null) && $fld->not_null) {
if (isset($fld->default_value) && strlen($fld->default_value)) {
continue;
}
else {
$this->Error("Cannot set field $name to NULL","Update");
return false;
}
}
}
if (isset($this->_original[$i]) && strcmp($val,$this->_original[$i]) == 0) {
continue;
}
if (is_null($this->_original[$i]) && is_null($val)) {
continue;
}
$valarr[] = $val;
$pairs[] = $this->_QName($name,$db).'='.$db->Param($cnt);
$cnt += 1;
}
if (!$cnt) {
return -1;
}
$sql = 'UPDATE '.$this->_table." SET ".implode(",",$pairs)." WHERE ".$where;
$ok = $db->Execute($sql,$valarr);
if ($ok) {
$this->_original = $neworig;
return 1;
}
return 0;
}
function GetAttributeNames()
{
$table = $this->TableInfo();
if (!$table) {
return false;
}
return array_keys($table->flds);
}
};
function adodb_GetActiveRecordsClass(&$db, $class, $table,$whereOrderBy,$bindarr, $primkeyArr,
$extra)
{
global $_ADODB_ACTIVE_DBS;
$save = $db->SetFetchMode(ADODB_FETCH_NUM);
$qry = "select * from ".$table;
if (!empty($whereOrderBy)) {
$qry .= ' WHERE '.$whereOrderBy;
}
if(isset($extra['limit'])) {
$rows = false;
if(isset($extra['offset'])) {
$rs = $db->SelectLimit($qry, $extra['limit'], $extra['offset'],$bindarr);
} else {
$rs = $db->SelectLimit($qry, $extra['limit'],-1,$bindarr);
}
if ($rs) {
while (!$rs->EOF) {
$rows[] = $rs->fields;
$rs->MoveNext();
}
}
} else
$rows = $db->GetAll($qry,$bindarr);
$db->SetFetchMode($save);
$false = false;
if ($rows === false) {
return $false;
}
if (!class_exists($class)) {
$db->outp_throw("Unknown class $class in GetActiveRecordsClass()",'GetActiveRecordsClass');
return $false;
}
$arr = array();
// arrRef will be the structure that knows about our objects.
// It is an associative array.
// We will, however, return arr, preserving regular 0.. order so that
// obj[0] can be used by app developpers.
$arrRef = array();
$bTos = array(); // Will store belongTo's indices if any
foreach($rows as $row) {
$obj = new $class($table,$primkeyArr,$db);
if ($obj->ErrorNo()){
$db->_errorMsg = $obj->ErrorMsg();
return $false;
}
$obj->Set($row);
$arr[] = $obj;
} // foreach($rows as $row)
return $arr;
}
PK P|]ʟ_ _ perf/perf-oci8.inc.phpnu W+A array('RATIOH',
"select round((1-(phy.value / (cur.value + con.value)))*100,2)
from v\$sysstat cur, v\$sysstat con, v\$sysstat phy
where cur.name = 'db block gets' and
con.name = 'consistent gets' and
phy.name = 'physical reads'",
'=WarnCacheRatio'),
'sql cache hit ratio' => array( 'RATIOH',
'select round(100*(sum(pins)-sum(reloads))/sum(pins),2) from v$librarycache',
'increase shared_pool_size if too ratio low'),
'datadict cache hit ratio' => array('RATIOH',
"select
round((1 - (sum(getmisses) / (sum(gets) +
sum(getmisses))))*100,2)
from v\$rowcache",
'increase shared_pool_size if too ratio low'),
'memory sort ratio' => array('RATIOH',
"SELECT ROUND((100 * b.VALUE) /DECODE ((a.VALUE + b.VALUE),
0,1,(a.VALUE + b.VALUE)),2)
FROM v\$sysstat a,
v\$sysstat b
WHERE a.name = 'sorts (disk)'
AND b.name = 'sorts (memory)'",
"% of memory sorts compared to disk sorts - should be over 95%"),
'IO',
'data reads' => array('IO',
"select value from v\$sysstat where name='physical reads'"),
'data writes' => array('IO',
"select value from v\$sysstat where name='physical writes'"),
'Data Cache',
'data cache buffers' => array( 'DATAC',
"select a.value/b.value from v\$parameter a, v\$parameter b
where a.name = 'db_cache_size' and b.name= 'db_block_size'",
'Number of cache buffers. Tune db_cache_size if the data cache hit ratio is too low.'),
'data cache blocksize' => array('DATAC',
"select value from v\$parameter where name='db_block_size'",
'' ),
'Memory Pools',
'Mem Max Target (11g+)' => array( 'DATAC',
"select value from v\$parameter where name = 'memory_max_target'",
'The memory_max_size is the maximum value to which memory_target can be set.' ),
'Memory target (11g+)' => array( 'DATAC',
"select value from v\$parameter where name = 'memory_target'",
'If memory_target is defined then SGA and PGA targets are consolidated into one memory_target.' ),
'SGA Max Size' => array( 'DATAC',
"select nvl(value,0)/1024.0/1024 || 'M' from v\$parameter where name = 'sga_max_size'",
'The sga_max_size is the maximum value to which sga_target can be set.' ),
'SGA target' => array( 'DATAC',
"select nvl(value,0)/1024.0/1024 || 'M' from v\$parameter where name = 'sga_target'",
'If sga_target is defined then data cache, shared, java and large pool size can be 0. This is because all these pools are consolidated into one sga_target.' ),
'PGA aggr target' => array( 'DATAC',
"select nvl(value,0)/1024.0/1024 || 'M' from v\$parameter where name = 'pga_aggregate_target'",
'If pga_aggregate_target is defined then this is the maximum memory that can be allocated for cursor operations such as sorts, group by, joins, merges. When in doubt, set it to 20% of sga_target.' ),
'data cache size' => array('DATAC',
"select value from v\$parameter where name = 'db_cache_size'",
'db_cache_size' ),
'shared pool size' => array('DATAC',
"select value from v\$parameter where name = 'shared_pool_size'",
'shared_pool_size, which holds shared sql, stored procedures, dict cache and similar shared structs' ),
'java pool size' => array('DATAJ',
"select value from v\$parameter where name = 'java_pool_size'",
'java_pool_size' ),
'large pool buffer size' => array('CACHE',
"select value from v\$parameter where name='large_pool_size'",
'this pool is for large mem allocations (not because it is larger than shared pool), for MTS sessions, parallel queries, io buffers (large_pool_size) ' ),
'dynamic memory usage' => array('CACHE', "select '-' from dual", '=DynMemoryUsage'),
'Connections',
'current connections' => array('SESS',
'select count(*) from sys.v_$session where username is not null',
''),
'max connections' => array( 'SESS',
"select value from v\$parameter where name='sessions'",
''),
'Memory Utilization',
'data cache utilization ratio' => array('RATIOU',
"select round((1-bytes/sgasize)*100, 2)
from (select sum(bytes) sgasize from sys.v_\$sgastat) s, sys.v_\$sgastat f
where name = 'free memory' and pool = 'shared pool'",
'Percentage of data cache actually in use - should be over 85%'),
'shared pool utilization ratio' => array('RATIOU',
'select round((sga.bytes/case when p.value=0 then sga.bytes else to_number(p.value) end)*100,2)
from v$sgastat sga, v$parameter p
where sga.name = \'free memory\' and sga.pool = \'shared pool\'
and p.name = \'shared_pool_size\'',
'Percentage of shared pool actually used - too low is bad, too high is worse'),
'large pool utilization ratio' => array('RATIOU',
"select round((1-bytes/sgasize)*100, 2)
from (select sum(bytes) sgasize from sys.v_\$sgastat) s, sys.v_\$sgastat f
where name = 'free memory' and pool = 'large pool'",
'Percentage of large_pool actually in use - too low is bad, too high is worse'),
'sort buffer size' => array('CACHE',
"select value from v\$parameter where name='sort_area_size'",
'max in-mem sort_area_size (per query), uses memory in pga' ),
/*'pga usage at peak' => array('RATIOU',
'=PGA','Mb utilization at peak transactions (requires Oracle 9i+)'),*/
'Transactions',
'rollback segments' => array('ROLLBACK',
"select count(*) from sys.v_\$rollstat",
''),
'peak transactions' => array('ROLLBACK',
"select max_utilization tx_hwm
from sys.v_\$resource_limit
where resource_name = 'transactions'",
'Taken from high-water-mark'),
'max transactions' => array('ROLLBACK',
"select value from v\$parameter where name = 'transactions'",
'max transactions / rollback segments < 3.5 (or transactions_per_rollback_segment)'),
'Parameters',
'cursor sharing' => array('CURSOR',
"select value from v\$parameter where name = 'cursor_sharing'",
'Cursor reuse strategy. Recommended is FORCE (8i+) or SIMILAR (9i+). See cursor_sharing.'),
/*
'cursor reuse' => array('CURSOR',
"select count(*) from (select sql_text_wo_constants, count(*)
from t1
group by sql_text_wo_constants
having count(*) > 100)",'These are sql statements that should be using bind variables'),*/
'index cache cost' => array('COST',
"select value from v\$parameter where name = 'optimizer_index_caching'",
'=WarnIndexCost'),
'random page cost' => array('COST',
"select value from v\$parameter where name = 'optimizer_index_cost_adj'",
'=WarnPageCost'),
'Waits',
'Recent wait events' => array('WAITS','select \'Top 5 events\' from dual','=TopRecentWaits'),
// 'Historical wait SQL' => array('WAITS','select \'Last 2 days\' from dual','=TopHistoricalWaits'), -- requires AWR license
'Backup',
'Achivelog Mode' => array('BACKUP', 'select log_mode from v$database', '=LogMode'),
'DBID' => array('BACKUP','select dbid from v$database','Primary key of database, used for recovery with an RMAN Recovery Catalog'),
'Archive Log Dest' => array('BACKUP', "SELECT NVL(v1.value,v2.value)
FROM v\$parameter v1, v\$parameter v2 WHERE v1.name='log_archive_dest' AND v2.name='log_archive_dest_10'", ''),
'Flashback Area' => array('BACKUP', "select nvl(value,'Flashback Area not used') from v\$parameter where name=lower('DB_RECOVERY_FILE_DEST')", 'Flashback area is a folder where all backup data and logs can be stored and managed by Oracle. If Error: message displayed, then it is not in use.'),
'Flashback Usage' => array('BACKUP', "select nvl('-','Flashback Area not used') from v\$parameter where name=lower('DB_RECOVERY_FILE_DEST')", '=FlashUsage', 'Flashback area usage.'),
'Control File Keep Time' => array('BACKUP', "select value from v\$parameter where name='control_file_record_keep_time'",'No of days to keep RMAN info in control file. Recommended set to x2 or x3 times the frequency of your full backup.'),
'Recent RMAN Jobs' => array('BACKUP', "select '-' from dual", "=RMAN"),
// 'Control File Keep Time' => array('BACKUP', "select value from v\$parameter where name='control_file_record_keep_time'",'No of days to keep RMAN info in control file. I recommend it be set to x2 or x3 times the frequency of your full backup.'),
'Storage', 'Tablespaces' => array('TABLESPACE', "select '-' from dual", "=TableSpace"),
false
);
function __construct(&$conn)
{
global $gSQLBlockRows;
$gSQLBlockRows = 1000;
$savelog = $conn->LogSQL(false);
$this->version = $conn->ServerInfo();
$conn->LogSQL($savelog);
$this->conn = $conn;
}
function LogMode()
{
$mode = $this->conn->GetOne("select log_mode from v\$database");
if ($mode == 'ARCHIVELOG') return 'To turn off archivelog:
SQLPLUS> connect sys as sysdba;
SQLPLUS> shutdown immediate;
SQLPLUS> startup mount exclusive;
SQLPLUS> alter database noarchivelog;
SQLPLUS> alter database open;
';
return 'To turn on archivelog:
SQLPLUS> connect sys as sysdba;
SQLPLUS> shutdown immediate;
SQLPLUS> startup mount exclusive;
SQLPLUS> alter database archivelog;
SQLPLUS> archive log start;
SQLPLUS> alter database open;
';
}
function TopRecentWaits()
{
$rs = $this->conn->Execute("select * from (
select event, round(100*time_waited/(select sum(time_waited) from v\$system_event where wait_class <> 'Idle'),1) \"% Wait\",
total_waits,time_waited, average_wait,wait_class from v\$system_event where wait_class <> 'Idle' order by 2 desc
) where rownum <=5");
$ret = rs2html($rs,false,false,false,false);
return " ".$ret."
";
}
function TopHistoricalWaits()
{
$days = 2;
$rs = $this->conn->Execute("select * from ( SELECT
b.wait_class,B.NAME,
round(sum(wait_time+TIME_WAITED)/1000000) waitsecs,
parsing_schema_name,
C.SQL_TEXT, a.sql_id
FROM V\$ACTIVE_SESSION_HISTORY A
join V\$EVENT_NAME B on A.EVENT# = B.EVENT#
join V\$SQLAREA C on A.SQL_ID = C.SQL_ID
WHERE A.SAMPLE_TIME BETWEEN sysdate-$days and sysdate
and parsing_schema_name not in ('SYS','SYSMAN','DBSNMP','SYSTEM')
GROUP BY b.wait_class,parsing_schema_name,C.SQL_TEXT, B.NAME,A.sql_id
order by 3 desc) where rownum <=10");
$ret = rs2html($rs,false,false,false,false);
return " ".$ret."
";
}
function TableSpace()
{
$rs = $this->conn->Execute(
"select tablespace_name,round(sum(bytes)/1024/1024) as Used_MB,round(sum(maxbytes)/1024/1024) as Max_MB, round(sum(bytes)/sum(maxbytes),4) * 100 as PCT
from dba_data_files
group by tablespace_name order by 2 desc");
$ret = "Tablespace".rs2html($rs,false,false,false,false);
$rs = $this->conn->Execute("select * from dba_data_files order by tablespace_name, 1");
$ret .= "
Datafile".rs2html($rs,false,false,false,false);
return "
".$ret."
";
}
function RMAN()
{
$rs = $this->conn->Execute("select * from (select start_time, end_time, operation, status, mbytes_processed, output_device_type
from V\$RMAN_STATUS order by start_time desc) where rownum <=10");
$ret = rs2html($rs,false,false,false,false);
return " ".$ret."
";
}
function DynMemoryUsage()
{
if (@$this->version['version'] >= 11) {
$rs = $this->conn->Execute("select component, current_size/1024./1024 as \"CurrSize (M)\" from V\$MEMORY_DYNAMIC_COMPONENTS");
} else
$rs = $this->conn->Execute("select name, round(bytes/1024./1024,2) as \"CurrSize (M)\" from V\$sgainfo");
$ret = rs2html($rs,false,false,false,false);
return " ".$ret."
";
}
function FlashUsage()
{
$rs = $this->conn->Execute("select * from V\$FLASH_RECOVERY_AREA_USAGE");
$ret = rs2html($rs,false,false,false,false);
return " ".$ret."
";
}
function WarnPageCost($val)
{
if ($val == 100 && $this->version['version'] < 10) $s = 'Too High. ';
else $s = '';
return $s.'Recommended is 20-50 for TP, and 50 for data warehouses. Default is 100. See optimizer_index_cost_adj. ';
}
function WarnIndexCost($val)
{
if ($val == 0 && $this->version['version'] < 10) $s = 'Too Low. ';
else $s = '';
return $s.'Percentage of indexed data blocks expected in the cache.
Recommended is 20 (fast disk array) to 30 (slower hard disks). Default is 0.
See optimizer_index_caching.';
}
function PGA()
{
//if ($this->version['version'] < 9) return 'Oracle 9i or later required';
}
function PGA_Advice()
{
$t = "PGA Advice Estimate
";
if ($this->version['version'] < 9) return $t.'Oracle 9i or later required';
$rs = $this->conn->Execute('select a.MB,
case when a.targ = 1 then \'<<= Current \'
when a.targ < 1 or a.pct <= b.pct then null
else
\'- BETTER than Current by \'||round(a.pct/b.pct*100-100,2)||\'%\' end as "Percent Improved",
a.targ as "PGA Size Factor",a.pct "% Perf"
from
(select round(pga_target_for_estimate/1024.0/1024.0,0) MB,
pga_target_factor targ,estd_pga_cache_hit_percentage pct,rownum as r
from v$pga_target_advice) a left join
(select round(pga_target_for_estimate/1024.0/1024.0,0) MB,
pga_target_factor targ,estd_pga_cache_hit_percentage pct,rownum as r
from v$pga_target_advice) b on
a.r = b.r+1 where
b.pct < 100');
if (!$rs) return $t."Only in 9i or later";
// $rs->Close();
if ($rs->EOF) return $t."PGA could be too big";
return $t.rs2html($rs,false,false,true,false);
}
function Explain($sql,$partial=false)
{
$savelog = $this->conn->LogSQL(false);
$rs = $this->conn->SelectLimit("select ID FROM PLAN_TABLE");
if (!$rs) {
echo "Missing PLAN_TABLE
CREATE TABLE PLAN_TABLE (
STATEMENT_ID VARCHAR2(30),
TIMESTAMP DATE,
REMARKS VARCHAR2(80),
OPERATION VARCHAR2(30),
OPTIONS VARCHAR2(30),
OBJECT_NODE VARCHAR2(128),
OBJECT_OWNER VARCHAR2(30),
OBJECT_NAME VARCHAR2(30),
OBJECT_INSTANCE NUMBER(38),
OBJECT_TYPE VARCHAR2(30),
OPTIMIZER VARCHAR2(255),
SEARCH_COLUMNS NUMBER,
ID NUMBER(38),
PARENT_ID NUMBER(38),
POSITION NUMBER(38),
COST NUMBER(38),
CARDINALITY NUMBER(38),
BYTES NUMBER(38),
OTHER_TAG VARCHAR2(255),
PARTITION_START VARCHAR2(255),
PARTITION_STOP VARCHAR2(255),
PARTITION_ID NUMBER(38),
OTHER LONG,
DISTRIBUTION VARCHAR2(30)
);
";
return false;
}
$rs->Close();
// $this->conn->debug=1;
if ($partial) {
$sqlq = $this->conn->qstr($sql.'%');
$arr = $this->conn->GetArray("select distinct sql1 from adodb_logsql where sql1 like $sqlq");
if ($arr) {
foreach($arr as $row) {
$sql = reset($row);
if (crc32($sql) == $partial) break;
}
}
}
$s = "Explain: ".htmlspecialchars($sql)."
";
$this->conn->BeginTrans();
$id = "ADODB ".microtime();
$rs = $this->conn->Execute("EXPLAIN PLAN SET STATEMENT_ID='$id' FOR $sql");
$m = $this->conn->ErrorMsg();
if ($m) {
$this->conn->RollbackTrans();
$this->conn->LogSQL($savelog);
$s .= "$m
";
return $s;
}
$rs = $this->conn->Execute("
select
''||lpad('--', (level-1)*2,'-') || trim(operation) || ' ' || trim(options)||'
' as Operation,
object_name,COST,CARDINALITY,bytes
FROM plan_table
START WITH id = 0 and STATEMENT_ID='$id'
CONNECT BY prior id=parent_id and statement_id='$id'");
$s .= rs2html($rs,false,false,false,false);
$this->conn->RollbackTrans();
$this->conn->LogSQL($savelog);
$s .= $this->Tracer($sql,$partial);
return $s;
}
function CheckMemory()
{
if ($this->version['version'] < 9) return 'Oracle 9i or later required';
$rs = $this->conn->Execute("
select a.name Buffer_Pool, b.size_for_estimate as cache_mb_estimate,
case when b.size_factor=1 then
'<<= Current'
when a.estd_physical_read_factor-b.estd_physical_read_factor > 0.001 and b.estd_physical_read_factor<1 then
'- BETTER than current by ' || round((1-b.estd_physical_read_factor)/b.estd_physical_read_factor*100,2) || '%'
else ' ' end as RATING,
b.estd_physical_read_factor \"Phys. Reads Factor\",
round((a.estd_physical_read_factor-b.estd_physical_read_factor)/b.estd_physical_read_factor*100,2) as \"% Improve\"
from (select size_for_estimate,size_factor,estd_physical_read_factor,rownum r,name from v\$db_cache_advice order by name,1) a ,
(select size_for_estimate,size_factor,estd_physical_read_factor,rownum r,name from v\$db_cache_advice order by name,1) b
where a.r = b.r-1 and a.name = b.name
");
if (!$rs) return false;
/*
The v$db_cache_advice utility show the marginal changes in physical data block reads for different sizes of db_cache_size
*/
$s = "Data Cache Advice Estimate
";
if ($rs->EOF) {
$s .= "Cache that is 50% of current size is still too big
";
} else {
$s .= "Ideal size of Data Cache is when %BETTER gets close to zero.";
$s .= rs2html($rs,false,false,false,false);
}
return $s.$this->PGA_Advice();
}
/*
Generate html for suspicious/expensive sql
*/
function tohtml(&$rs,$type)
{
$o1 = $rs->FetchField(0);
$o2 = $rs->FetchField(1);
$o3 = $rs->FetchField(2);
if ($rs->EOF) return 'None found
';
$check = '';
$sql = '';
$s = "\n\n".$o1->name.' | '.$o2->name.' | '.$o3->name.' |
';
while (!$rs->EOF) {
if ($check != $rs->fields[0].'::'.$rs->fields[1]) {
if ($check) {
$carr = explode('::',$check);
$prefix = "';
$suffix = '';
if (strlen($prefix)>2000) {
$prefix = '';
$suffix = '';
}
$s .= "\n".$carr[0].' | '.$carr[1].' | '.$prefix.$sql.$suffix.' |
';
}
$sql = $rs->fields[2];
$check = $rs->fields[0].'::'.$rs->fields[1];
} else
$sql .= $rs->fields[2];
if (substr($sql,strlen($sql)-1) == "\0") $sql = substr($sql,0,strlen($sql)-1);
$rs->MoveNext();
}
$rs->Close();
$carr = explode('::',$check);
$prefix = "';
$suffix = '';
if (strlen($prefix)>2000) {
$prefix = '';
$suffix = '';
}
$s .= "\n".$carr[0].' | '.$carr[1].' | '.$prefix.$sql.$suffix.' |
';
return $s."
\n\n";
}
// code thanks to Ixora.
// http://www.ixora.com.au/scripts/query_opt.htm
// requires oracle 8.1.7 or later
function SuspiciousSQL($numsql=10)
{
$sql = "
select
substr(to_char(s.pct, '99.00'), 2) || '%' load,
s.executions executes,
p.sql_text
from
(
select
address,
buffer_gets,
executions,
pct,
rank() over (order by buffer_gets desc) ranking
from
(
select
address,
buffer_gets,
executions,
100 * ratio_to_report(buffer_gets) over () pct
from
sys.v_\$sql
where
command_type != 47 and module != 'T.O.A.D.'
)
where
buffer_gets > 50 * executions
) s,
sys.v_\$sqltext p
where
s.ranking <= $numsql and
p.address = s.address
order by
1 desc, s.address, p.piece";
global $ADODB_CACHE_MODE;
if (isset($_GET['expsixora']) && isset($_GET['sql'])) {
$partial = empty($_GET['part']);
echo "".$this->Explain($_GET['sql'],$partial)."\n";
}
if (isset($_GET['sql'])) return $this->_SuspiciousSQL($numsql);
$s = '';
$timer = time();
$s .= $this->_SuspiciousSQL($numsql);
$timer = time() - $timer;
if ($timer > $this->noShowIxora) return $s;
$s .= '';
$save = $ADODB_CACHE_MODE;
$ADODB_CACHE_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$savelog = $this->conn->LogSQL(false);
$rs = $this->conn->SelectLimit($sql);
$this->conn->LogSQL($savelog);
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_CACHE_MODE = $save;
if ($rs) {
$s .= "\n
Ixora Suspicious SQL
";
$s .= $this->tohtml($rs,'expsixora');
}
return $s;
}
// code thanks to Ixora.
// http://www.ixora.com.au/scripts/query_opt.htm
// requires oracle 8.1.7 or later
function ExpensiveSQL($numsql = 10)
{
$sql = "
select
substr(to_char(s.pct, '99.00'), 2) || '%' load,
s.executions executes,
p.sql_text
from
(
select
address,
disk_reads,
executions,
pct,
rank() over (order by disk_reads desc) ranking
from
(
select
address,
disk_reads,
executions,
100 * ratio_to_report(disk_reads) over () pct
from
sys.v_\$sql
where
command_type != 47 and module != 'T.O.A.D.'
)
where
disk_reads > 50 * executions
) s,
sys.v_\$sqltext p
where
s.ranking <= $numsql and
p.address = s.address
order by
1 desc, s.address, p.piece
";
global $ADODB_CACHE_MODE;
if (isset($_GET['expeixora']) && isset($_GET['sql'])) {
$partial = empty($_GET['part']);
echo "".$this->Explain($_GET['sql'],$partial)."\n";
}
if (isset($_GET['sql'])) {
$var = $this->_ExpensiveSQL($numsql);
return $var;
}
$s = '';
$timer = time();
$s .= $this->_ExpensiveSQL($numsql);
$timer = time() - $timer;
if ($timer > $this->noShowIxora) return $s;
$s .= '';
$save = $ADODB_CACHE_MODE;
$ADODB_CACHE_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$savelog = $this->conn->LogSQL(false);
$rs = $this->conn->Execute($sql);
$this->conn->LogSQL($savelog);
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_CACHE_MODE = $save;
if ($rs) {
$s .= "\n
Ixora Expensive SQL
";
$s .= $this->tohtml($rs,'expeixora');
}
return $s;
}
function clearsql()
{
$perf_table = adodb_perf::table();
// using the naive "delete from $perf_table where created<".$this->conn->sysTimeStamp will cause the table to lock, possibly
// for a long time
$sql =
"DECLARE cnt pls_integer;
BEGIN
cnt := 0;
FOR rec IN (SELECT ROWID AS rr FROM $perf_table WHERE createdconn->Execute($sql);
}
}
PK Pl perf/perf-mysql.inc.phpnu W+A array('RATIO',
'=GetKeyHitRatio',
'=WarnCacheRatio'),
'InnoDB cache hit ratio' => array('RATIO',
'=GetInnoDBHitRatio',
'=WarnCacheRatio'),
'data cache hit ratio' => array('HIDE', # only if called
'=FindDBHitRatio',
'=WarnCacheRatio'),
'sql cache hit ratio' => array('RATIO',
'=GetQHitRatio',
''),
'IO',
'data reads' => array('IO',
'=GetReads',
'Number of selects (Key_reads is not accurate)'),
'data writes' => array('IO',
'=GetWrites',
'Number of inserts/updates/deletes * coef (Key_writes is not accurate)'),
'Data Cache',
'MyISAM data cache size' => array('DATAC',
array("show variables", 'key_buffer_size'),
'' ),
'BDB data cache size' => array('DATAC',
array("show variables", 'bdb_cache_size'),
'' ),
'InnoDB data cache size' => array('DATAC',
array("show variables", 'innodb_buffer_pool_size'),
'' ),
'Memory Usage',
'read buffer size' => array('CACHE',
array("show variables", 'read_buffer_size'),
'(per session)'),
'sort buffer size' => array('CACHE',
array("show variables", 'sort_buffer_size'),
'Size of sort buffer (per session)' ),
'table cache' => array('CACHE',
array("show variables", 'table_cache'),
'Number of tables to keep open'),
'Connections',
'current connections' => array('SESS',
array('show status','Threads_connected'),
''),
'max connections' => array( 'SESS',
array("show variables",'max_connections'),
''),
false
);
function __construct(&$conn)
{
$this->conn = $conn;
}
function Explain($sql,$partial=false)
{
if (strtoupper(substr(trim($sql),0,6)) !== 'SELECT') return 'Unable to EXPLAIN non-select statement
';
$save = $this->conn->LogSQL(false);
if ($partial) {
$sqlq = $this->conn->qstr($sql.'%');
$arr = $this->conn->GetArray("select distinct sql1 from adodb_logsql where sql1 like $sqlq");
if ($arr) {
foreach($arr as $row) {
$sql = reset($row);
if (crc32($sql) == $partial) break;
}
}
}
$sql = str_replace('?',"''",$sql);
if ($partial) {
$sqlq = $this->conn->qstr($sql.'%');
$sql = $this->conn->GetOne("select sql1 from adodb_logsql where sql1 like $sqlq");
}
$s = 'Explain: '.htmlspecialchars($sql).'
';
$rs = $this->conn->Execute('EXPLAIN '.$sql);
$s .= rs2html($rs,false,false,false,false);
$this->conn->LogSQL($save);
$s .= $this->Tracer($sql);
return $s;
}
function tables($orderby='1')
{
if (!$this->tablesSQL) return false;
$rs = $this->conn->Execute($this->tablesSQL);
if (!$rs) return false;
$html = rs2html($rs,false,false,false,false);
return $html;
}
function GetReads()
{
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$rs = $this->conn->Execute('show status');
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_FETCH_MODE = $save;
if (!$rs) return 0;
$val = 0;
while (!$rs->EOF) {
switch($rs->fields[0]) {
case 'Com_select':
$val = $rs->fields[1];
$rs->Close();
return $val;
}
$rs->MoveNext();
}
$rs->Close();
return $val;
}
function GetWrites()
{
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$rs = $this->conn->Execute('show status');
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_FETCH_MODE = $save;
if (!$rs) return 0;
$val = 0.0;
while (!$rs->EOF) {
switch($rs->fields[0]) {
case 'Com_insert':
$val += $rs->fields[1]; break;
case 'Com_delete':
$val += $rs->fields[1]; break;
case 'Com_update':
$val += $rs->fields[1]/2;
$rs->Close();
return $val;
}
$rs->MoveNext();
}
$rs->Close();
return $val;
}
function FindDBHitRatio()
{
// first find out type of table
//$this->conn->debug=1;
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$rs = $this->conn->Execute('show table status');
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_FETCH_MODE = $save;
if (!$rs) return '';
$type = strtoupper($rs->fields[1]);
$rs->Close();
switch($type){
case 'MYISAM':
case 'ISAM':
return $this->DBParameter('MyISAM cache hit ratio').' (MyISAM)';
case 'INNODB':
return $this->DBParameter('InnoDB cache hit ratio').' (InnoDB)';
default:
return $type.' not supported';
}
}
function GetQHitRatio()
{
//Total number of queries = Qcache_inserts + Qcache_hits + Qcache_not_cached
$hits = $this->_DBParameter(array("show status","Qcache_hits"));
$total = $this->_DBParameter(array("show status","Qcache_inserts"));
$total += $this->_DBParameter(array("show status","Qcache_not_cached"));
$total += $hits;
if ($total) return round(($hits*100)/$total,2);
return 0;
}
/*
Use session variable to store Hit percentage, because MySQL
does not remember last value of SHOW INNODB STATUS hit ratio
# 1st query to SHOW INNODB STATUS
0.00 reads/s, 0.00 creates/s, 0.00 writes/s
Buffer pool hit rate 1000 / 1000
# 2nd query to SHOW INNODB STATUS
0.00 reads/s, 0.00 creates/s, 0.00 writes/s
No buffer pool activity since the last printout
*/
function GetInnoDBHitRatio()
{
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$rs = $this->conn->Execute('show engine innodb status');
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_FETCH_MODE = $save;
if (!$rs || $rs->EOF) return 0;
$stat = $rs->fields[0];
$rs->Close();
$at = strpos($stat,'Buffer pool hit rate');
$stat = substr($stat,$at,200);
if (preg_match('!Buffer pool hit rate\s*([0-9]*) / ([0-9]*)!',$stat,$arr)) {
$val = 100*$arr[1]/$arr[2];
$_SESSION['INNODB_HIT_PCT'] = $val;
return round($val,2);
} else {
if (isset($_SESSION['INNODB_HIT_PCT'])) return $_SESSION['INNODB_HIT_PCT'];
return 0;
}
return 0;
}
function GetKeyHitRatio()
{
$hits = $this->_DBParameter(array("show status","Key_read_requests"));
$reqs = $this->_DBParameter(array("show status","Key_reads"));
if ($reqs == 0) return 0;
return round(($hits/($reqs+$hits))*100,2);
}
// start hack
var $optimizeTableLow = 'CHECK TABLE %s FAST QUICK';
var $optimizeTableHigh = 'OPTIMIZE TABLE %s';
/**
* @see adodb_perf#optimizeTable
*/
function optimizeTable( $table, $mode = ADODB_OPT_LOW)
{
if ( !is_string( $table)) return false;
$conn = $this->conn;
if ( !$conn) return false;
$sql = '';
switch( $mode) {
case ADODB_OPT_LOW : $sql = $this->optimizeTableLow; break;
case ADODB_OPT_HIGH : $sql = $this->optimizeTableHigh; break;
default :
{
// May dont use __FUNCTION__ constant for BC (__FUNCTION__ Added in PHP 4.3.0)
ADOConnection::outp( sprintf( "%s: '%s' using of undefined mode '%s'
", __CLASS__, __FUNCTION__, $mode));
return false;
}
}
$sql = sprintf( $sql, $table);
return $conn->Execute( $sql) !== false;
}
// end hack
}
PK PI!0 perf/perf-db2.inc.phpnu W+A array('RATIO',
"SELECT
case when sum(POOL_DATA_L_READS+POOL_INDEX_L_READS)=0 then 0
else 100*(1-sum(POOL_DATA_P_READS+POOL_INDEX_P_READS)/sum(POOL_DATA_L_READS+POOL_INDEX_L_READS)) end
FROM TABLE(SNAPSHOT_APPL('',-2)) as t",
'=WarnCacheRatio'),
'Data Cache',
'data cache buffers' => array('DATAC',
'select sum(npages) from SYSCAT.BUFFERPOOLS',
'See tuning reference.' ),
'cache blocksize' => array('DATAC',
'select avg(pagesize) from SYSCAT.BUFFERPOOLS',
'' ),
'data cache size' => array('DATAC',
'select sum(npages*pagesize) from SYSCAT.BUFFERPOOLS',
'' ),
'Connections',
'current connections' => array('SESS',
"SELECT count(*) FROM TABLE(SNAPSHOT_APPL_INFO('',-2)) as t",
''),
false
);
function __construct(&$conn)
{
$this->conn = $conn;
}
function Explain($sql,$partial=false)
{
$save = $this->conn->LogSQL(false);
if ($partial) {
$sqlq = $this->conn->qstr($sql.'%');
$arr = $this->conn->GetArray("select distinct sql1 from adodb_logsql where sql1 like $sqlq");
if ($arr) {
foreach($arr as $row) {
$sql = reset($row);
if (crc32($sql) == $partial) break;
}
}
}
$qno = rand();
$ok = $this->conn->Execute("EXPLAIN PLAN SET QUERYNO=$qno FOR $sql");
ob_start();
if (!$ok) echo "Have EXPLAIN tables been created?
";
else {
$rs = $this->conn->Execute("select * from explain_statement where queryno=$qno");
if ($rs) rs2html($rs);
}
$s = ob_get_contents();
ob_end_clean();
$this->conn->LogSQL($save);
$s .= $this->Tracer($sql);
return $s;
}
/**
* Gets a list of tables
*
* @param int $throwaway discarded variable to match the parent method
* @return string The formatted table list
*/
function Tables($throwaway=0)
{
$rs = $this->conn->Execute("select tabschema,tabname,card as rows,
npages pages_used,fpages pages_allocated, tbspace tablespace
from syscat.tables where tabschema not in ('SYSCAT','SYSIBM','SYSSTAT') order by 1,2");
return rs2html($rs,false,false,false,false);
}
}
PK Pv$; ; perf/perf-postgres.inc.phpnu W+A array('RATIO',
"select case when count(*)=3 then 'TRUE' else 'FALSE' end from pg_settings where (name='stats_block_level' or name='stats_row_level' or name='stats_start_collector') and setting='on' ",
'Value must be TRUE to enable hit ratio statistics (stats_start_collector,stats_row_level and stats_block_level must be set to true in postgresql.conf)'),
'data cache hit ratio' => array('RATIO',
"select case when blks_hit=0 then 0 else round( ((1-blks_read::float/blks_hit)*100)::numeric, 2) end from pg_stat_database where datname='\$DATABASE'",
'=WarnCacheRatio'),
'IO',
'data reads' => array('IO',
'select sum(heap_blks_read+toast_blks_read) from pg_statio_user_tables',
),
'data writes' => array('IO',
'select round((sum(n_tup_ins/4.0+n_tup_upd/8.0+n_tup_del/4.0)/16)::numeric,2) from pg_stat_user_tables',
'Count of inserts/updates/deletes * coef'),
'Data Cache',
'data cache buffers' => array('DATAC',
"select setting from pg_settings where name='shared_buffers'",
'Number of cache buffers. Tuning'),
'cache blocksize' => array('DATAC',
'select 8192',
'(estimate)' ),
'data cache size' => array( 'DATAC',
"select setting::integer*8192 from pg_settings where name='shared_buffers'",
'' ),
'operating system cache size' => array( 'DATA',
"select setting::integer*8192 from pg_settings where name='effective_cache_size'",
'(effective cache size)' ),
'Memory Usage',
# Postgres 7.5 changelog: Rename server parameters SortMem and VacuumMem to work_mem and maintenance_work_mem;
'sort/work buffer size' => array('CACHE',
"select setting::integer*1024 from pg_settings where name='sort_mem' or name = 'work_mem' order by name",
'Size of sort buffer (per query)' ),
'Connections',
'current connections' => array('SESS',
'select count(*) from pg_stat_activity',
''),
'max connections' => array('SESS',
"select setting from pg_settings where name='max_connections'",
''),
'Parameters',
'rollback buffers' => array('COST',
"select setting from pg_settings where name='wal_buffers'",
'WAL buffers'),
'random page cost' => array('COST',
"select setting from pg_settings where name='random_page_cost'",
'Cost of doing a seek (default=4). See random_page_cost'),
false
);
function __construct(&$conn)
{
$this->conn = $conn;
}
var $optimizeTableLow = 'VACUUM %s';
var $optimizeTableHigh = 'VACUUM ANALYZE %s';
/**
* @see adodb_perf#optimizeTable
*/
function optimizeTable($table, $mode = ADODB_OPT_LOW)
{
if(! is_string($table)) return false;
$conn = $this->conn;
if (! $conn) return false;
$sql = '';
switch($mode) {
case ADODB_OPT_LOW : $sql = $this->optimizeTableLow; break;
case ADODB_OPT_HIGH: $sql = $this->optimizeTableHigh; break;
default :
{
ADOConnection::outp(sprintf("%s: '%s' using of undefined mode '%s'
", __CLASS__, 'optimizeTable', $mode));
return false;
}
}
$sql = sprintf($sql, $table);
return $conn->Execute($sql) !== false;
}
function Explain($sql,$partial=false)
{
$save = $this->conn->LogSQL(false);
if ($partial) {
$sqlq = $this->conn->qstr($sql.'%');
$arr = $this->conn->GetArray("select distinct distinct sql1 from adodb_logsql where sql1 like $sqlq");
if ($arr) {
foreach($arr as $row) {
$sql = reset($row);
if (crc32($sql) == $partial) break;
}
}
}
$sql = str_replace('?',"''",$sql);
$s = 'Explain: '.htmlspecialchars($sql).'
';
$rs = $this->conn->Execute('EXPLAIN '.$sql);
$this->conn->LogSQL($save);
$s .= '';
if ($rs)
while (!$rs->EOF) {
$s .= reset($rs->fields)."\n";
$rs->MoveNext();
}
$s .= '
';
$s .= $this->Tracer($sql,$partial);
return $s;
}
}
PK P| perf/perf-mssqlnative.inc.phpnu W+A array('RATIO',
"select round((a.cntr_value*100.0)/b.cntr_value,2) from master.dbo.sysperfinfo a, master.dbo.sysperfinfo b where a.counter_name = 'Buffer cache hit ratio' and b.counter_name='Buffer cache hit ratio base'",
'=WarnCacheRatio'),
'prepared sql hit ratio' => array('RATIO',
array('dbcc cachestats','Prepared',1,100),
''),
'adhoc sql hit ratio' => array('RATIO',
array('dbcc cachestats','Adhoc',1,100),
''),
'IO',
'data reads' => array('IO',
"select cntr_value from master.dbo.sysperfinfo where counter_name = 'Page reads/sec'"),
'data writes' => array('IO',
"select cntr_value from master.dbo.sysperfinfo where counter_name = 'Page writes/sec'"),
'Data Cache',
'data cache size' => array('DATAC',
"select cntr_value*8192 from master.dbo.sysperfinfo where counter_name = 'Total Pages' and object_name='SQLServer:Buffer Manager'",
'' ),
'data cache blocksize' => array('DATAC',
"select 8192",'page size'),
'Connections',
'current connections' => array('SESS',
'=sp_who',
''),
'max connections' => array('SESS',
"SELECT @@MAX_CONNECTIONS",
''),
false
);
function __construct(&$conn)
{
if ($conn->dataProvider == 'odbc') {
$this->sql1 = 'sql1';
//$this->explain = false;
}
$this->conn =& $conn;
}
function Explain($sql,$partial=false)
{
$save = $this->conn->LogSQL(false);
if ($partial) {
$sqlq = $this->conn->qstr($sql.'%');
$arr = $this->conn->GetArray("select distinct sql1 from adodb_logsql where sql1 like $sqlq");
if ($arr) {
foreach($arr as $row) {
$sql = reset($row);
if (crc32($sql) == $partial) break;
}
}
}
$s = 'Explain: '.htmlspecialchars($sql).'
';
$this->conn->Execute("SET SHOWPLAN_ALL ON;");
$sql = str_replace('?',"''",$sql);
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
$rs =& $this->conn->Execute($sql);
//adodb_printr($rs);
$ADODB_FETCH_MODE = $save;
if ($rs) {
$rs->MoveNext();
$s .= ' Rows | IO | CPU | Plan |
';
while (!$rs->EOF) {
$s .= ''.round($rs->fields[8],1).' | '.round($rs->fields[9],3).' | '.round($rs->fields[10],3).' | '.htmlspecialchars($rs->fields[0])." |
\n"; ## NOTE CORRUPT tag is intentional!!!!
$rs->MoveNext();
}
$s .= '
';
$rs->NextRecordSet();
}
$this->conn->Execute("SET SHOWPLAN_ALL OFF;");
$this->conn->LogSQL($save);
$s .= $this->Tracer($sql);
return $s;
}
function Tables($orderby='1')
{
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
//$this->conn->debug=1;
$s = 'tablename | size_in_k | index size | reserved size |
';
$rs1 = $this->conn->Execute("select distinct name from sysobjects where xtype='U'");
if ($rs1) {
while (!$rs1->EOF) {
$tab = $rs1->fields[0];
$tabq = $this->conn->qstr($tab);
$rs2 = $this->conn->Execute("sp_spaceused $tabq");
if ($rs2) {
$s .= ''.$tab.' | '.$rs2->fields[3].' | '.$rs2->fields[4].' | '.$rs2->fields[2].' |
';
$rs2->Close();
}
$rs1->MoveNext();
}
$rs1->Close();
}
$ADODB_FETCH_MODE = $save;
return $s.'
';
}
function sp_who()
{
$arr = $this->conn->GetArray('sp_who');
return sizeof($arr);
}
function HealthCheck($cli=false)
{
$this->conn->Execute('dbcc traceon(3604)');
$html = adodb_perf::HealthCheck($cli);
$this->conn->Execute('dbcc traceoff(3604)');
return $html;
}
}
PK P?g perf/perf-mssql.inc.phpnu W+A array('RATIO',
"select round((a.cntr_value*100.0)/b.cntr_value,2) from master.dbo.sysperfinfo a, master.dbo.sysperfinfo b where a.counter_name = 'Buffer cache hit ratio' and b.counter_name='Buffer cache hit ratio base'",
'=WarnCacheRatio'),
'prepared sql hit ratio' => array('RATIO',
array('dbcc cachestats','Prepared',1,100),
''),
'adhoc sql hit ratio' => array('RATIO',
array('dbcc cachestats','Adhoc',1,100),
''),
'IO',
'data reads' => array('IO',
"select cntr_value from master.dbo.sysperfinfo where counter_name = 'Page reads/sec'"),
'data writes' => array('IO',
"select cntr_value from master.dbo.sysperfinfo where counter_name = 'Page writes/sec'"),
'Data Cache',
'data cache size' => array('DATAC',
"select cntr_value*8192 from master.dbo.sysperfinfo where counter_name = 'Total Pages' and object_name='SQLServer:Buffer Manager'",
'' ),
'data cache blocksize' => array('DATAC',
"select 8192",'page size'),
'Connections',
'current connections' => array('SESS',
'=sp_who',
''),
'max connections' => array('SESS',
"SELECT @@MAX_CONNECTIONS",
''),
false
);
function __construct(&$conn)
{
if ($conn->dataProvider == 'odbc') {
$this->sql1 = 'sql1';
//$this->explain = false;
}
$this->conn = $conn;
}
function Explain($sql,$partial=false)
{
$save = $this->conn->LogSQL(false);
if ($partial) {
$sqlq = $this->conn->qstr($sql.'%');
$arr = $this->conn->GetArray("select distinct sql1 from adodb_logsql where sql1 like $sqlq");
if ($arr) {
foreach($arr as $row) {
$sql = reset($row);
if (crc32($sql) == $partial) break;
}
}
}
$s = 'Explain: '.htmlspecialchars($sql).'
';
$this->conn->Execute("SET SHOWPLAN_ALL ON;");
$sql = str_replace('?',"''",$sql);
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
$rs = $this->conn->Execute($sql);
//adodb_printr($rs);
$ADODB_FETCH_MODE = $save;
if ($rs && !$rs->EOF) {
$rs->MoveNext();
$s .= ' Rows | IO | CPU | Plan |
';
while (!$rs->EOF) {
$s .= ''.round($rs->fields[8],1).' | '.round($rs->fields[9],3).' | '.round($rs->fields[10],3).' | '.htmlspecialchars($rs->fields[0])." |
\n"; ## NOTE CORRUPT tag is intentional!!!!
$rs->MoveNext();
}
$s .= '
';
$rs->NextRecordSet();
}
$this->conn->Execute("SET SHOWPLAN_ALL OFF;");
$this->conn->LogSQL($save);
$s .= $this->Tracer($sql);
return $s;
}
function Tables()
{
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
//$this->conn->debug=1;
$s = 'tablename | size_in_k | index size | reserved size |
';
$rs1 = $this->conn->Execute("select distinct name from sysobjects where xtype='U'");
if ($rs1) {
while (!$rs1->EOF) {
$tab = $rs1->fields[0];
$tabq = $this->conn->qstr($tab);
$rs2 = $this->conn->Execute("sp_spaceused $tabq");
if ($rs2) {
$s .= ''.$tab.' | '.$rs2->fields[3].' | '.$rs2->fields[4].' | '.$rs2->fields[2].' |
';
$rs2->Close();
}
$rs1->MoveNext();
}
$rs1->Close();
}
$ADODB_FETCH_MODE = $save;
return $s.'
';
}
function sp_who()
{
$arr = $this->conn->GetArray('sp_who');
return sizeof($arr);
}
function HealthCheck($cli=false)
{
$this->conn->Execute('dbcc traceon(3604)');
$html = adodb_perf::HealthCheck($cli);
$this->conn->Execute('dbcc traceoff(3604)');
return $html;
}
}
PK P"o o perf/perf-informix.inc.phpnu W+A array('RATIOH',
"select round((1-(wt.value / (rd.value + wr.value)))*100,2)
from sysmaster:sysprofile wr, sysmaster:sysprofile rd, sysmaster:sysprofile wt
where rd.name = 'pagreads' and
wr.name = 'pagwrites' and
wt.name = 'buffwts'",
'=WarnCacheRatio'),
'IO',
'data reads' => array('IO',
"select value from sysmaster:sysprofile where name='pagreads'",
'Page reads'),
'data writes' => array('IO',
"select value from sysmaster:sysprofile where name='pagwrites'",
'Page writes'),
'Connections',
'current connections' => array('SESS',
'select count(*) from sysmaster:syssessions',
'Number of sessions'),
false
);
function __construct(&$conn)
{
$this->conn = $conn;
}
}
PK Pc1g g " datadict/datadict-informix.inc.phpnu W+A debug) ADOConnection::outp("AlterColumnSQL not supported");
return array();
}
function DropColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
if ($this->debug) ADOConnection::outp("DropColumnSQL not supported");
return array();
}
// return string must begin with space
function _CreateSuffix($fname, &$ftype, $fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
if ($fautoinc) {
$ftype = 'SERIAL';
return '';
}
$suffix = '';
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fnotnull) $suffix .= ' NOT NULL';
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
}
PK PUP
datadict/datadict-sqlite.inc.phpnu W+A debug) ADOConnection::outp("AlterColumnSQL not supported natively by SQLite");
return array();
}
function DropColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
if ($this->debug) ADOConnection::outp("DropColumnSQL not supported natively by SQLite");
return array();
}
function RenameColumnSQL($tabname,$oldcolumn,$newcolumn,$flds='')
{
if ($this->debug) ADOConnection::outp("RenameColumnSQL not supported natively by SQLite");
return array();
}
}
PK P:ڒ$' $' % datadict/datadict-mssqlnative.inc.phpnu W+A type;
$len = $fieldobj->max_length;
}
$_typeConversion = array(
-155 => 'D',
93 => 'D',
-154 => 'D',
-2 => 'D',
91 => 'D',
12 => 'C',
1 => 'C',
-9 => 'C',
-8 => 'C',
-7 => 'L',
-6 => 'I2',
-5 => 'I8',
-11 => 'I',
4 => 'I',
5 => 'I4',
-1 => 'X',
-10 => 'X',
2 => 'N',
3 => 'N',
6 => 'N',
7 => 'N',
-152 => 'X',
-151 => 'X',
-4 => 'X',
-3 => 'X'
);
return $_typeConversion($t);
}
function ActualType($meta)
{
$DATE_TYPE = 'DATETIME';
switch(strtoupper($meta)) {
case 'C': return 'VARCHAR';
case 'XL': return (isset($this)) ? $this->typeXL : 'TEXT';
case 'X': return (isset($this)) ? $this->typeX : 'TEXT'; ## could be varchar(8000), but we want compat with oracle
case 'C2': return 'NVARCHAR';
case 'X2': return 'NTEXT';
case 'B': return 'IMAGE';
case 'D': return $DATE_TYPE;
case 'T': return 'TIME';
case 'L': return 'BIT';
case 'R':
case 'I': return 'INT';
case 'I1': return 'TINYINT';
case 'I2': return 'SMALLINT';
case 'I4': return 'INT';
case 'I8': return 'BIGINT';
case 'F': return 'REAL';
case 'N': return 'NUMERIC';
default:
print "RETURN $meta";
return $meta;
}
}
function AddColumnSQL($tabname, $flds)
{
$tabname = $this->TableName ($tabname);
$f = array();
list($lines,$pkey) = $this->_GenFields($flds);
$s = "ALTER TABLE $tabname $this->addCol";
foreach($lines as $v) {
$f[] = "\n $v";
}
$s .= implode(', ',$f);
$sql[] = $s;
return $sql;
}
function DefaultConstraintname($tabname, $colname)
{
$constraintname = false;
$rs = $this->connection->Execute(
"SELECT name FROM sys.default_constraints
WHERE object_name(parent_object_id) = '$tabname'
AND col_name(parent_object_id, parent_column_id) = '$colname'"
);
if ( is_object($rs) ) {
$row = $rs->FetchRow();
$constraintname = $row['name'];
}
return $constraintname;
}
function AlterColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
$tabname = $this->TableName ($tabname);
$sql = array();
list($lines,$pkey,$idxs) = $this->_GenFields($flds);
$alter = 'ALTER TABLE ' . $tabname . $this->alterCol . ' ';
foreach($lines as $v) {
$not_null = false;
if ($not_null = preg_match('/NOT NULL/i',$v)) {
$v = preg_replace('/NOT NULL/i','',$v);
}
if (preg_match('/^([^ ]+) .*DEFAULT (\'[^\']+\'|\"[^\"]+\"|[^ ]+)/',$v,$matches)) {
list(,$colname,$default) = $matches;
$v = preg_replace('/^' . preg_quote($colname) . '\s/', '', $v);
$t = trim(str_replace('DEFAULT '.$default,'',$v));
if ( $constraintname = $this->DefaultConstraintname($tabname,$colname) ) {
$sql[] = 'ALTER TABLE '.$tabname.' DROP CONSTRAINT '. $constraintname;
}
if ($not_null) {
$sql[] = $alter . $colname . ' ' . $t . ' NOT NULL';
} else {
$sql[] = $alter . $colname . ' ' . $t ;
}
$sql[] = 'ALTER TABLE ' . $tabname
. ' ADD CONSTRAINT DF__' . $tabname . '__' . $colname . '__' . dechex(rand())
. ' DEFAULT ' . $default . ' FOR ' . $colname;
} else {
$colname = strtok($v," ");
if ( $constraintname = $this->DefaultConstraintname($tabname,$colname) ) {
$sql[] = 'ALTER TABLE '.$tabname.' DROP CONSTRAINT '. $constraintname;
}
if ($not_null) {
$sql[] = $alter . $v . ' NOT NULL';
} else {
$sql[] = $alter . $v;
}
}
}
if (is_array($idxs)) {
foreach($idxs as $idx => $idxdef) {
$sql_idxs = $this->CreateIndexSql($idx, $tabname, $idxdef['cols'], $idxdef['opts']);
$sql = array_merge($sql, $sql_idxs);
}
}
return $sql;
}
/**
* Drop a column, syntax is ALTER TABLE table DROP COLUMN column,column
*
* @param string $tabname Table Name
* @param string[] $flds One, or an array of Fields To Drop
* @param string $tableflds Throwaway value to make the function match the parent
* @param string $tableoptions Throway value to make the function match the parent
*
* @return string The SQL necessary to drop the column
*/
function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
$tabname = $this->TableName ($tabname);
if (!is_array($flds))
$flds = explode(',',$flds);
$f = array();
$s = 'ALTER TABLE ' . $tabname;
foreach($flds as $v) {
if ( $constraintname = $this->DefaultConstraintname($tabname,$v) ) {
$sql[] = 'ALTER TABLE ' . $tabname . ' DROP CONSTRAINT ' . $constraintname;
}
$f[] = ' DROP COLUMN ' . $this->NameQuote($v);
}
$s .= implode(', ',$f);
$sql[] = $s;
return $sql;
}
// return string must begin with space
function _CreateSuffix($fname,&$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
$suffix = '';
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fautoinc) $suffix .= ' IDENTITY(1,1)';
if ($fnotnull) $suffix .= ' NOT NULL';
else if ($suffix == '') $suffix .= ' NULL';
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
/*
CREATE TABLE
[ database_name.[ owner ] . | owner. ] table_name
( { < column_definition >
| column_name AS computed_column_expression
| < table_constraint > ::= [ CONSTRAINT constraint_name ] }
| [ { PRIMARY KEY | UNIQUE } [ ,...n ]
)
[ ON { filegroup | DEFAULT } ]
[ TEXTIMAGE_ON { filegroup | DEFAULT } ]
< column_definition > ::= { column_name data_type }
[ COLLATE < collation_name > ]
[ [ DEFAULT constant_expression ]
| [ IDENTITY [ ( seed , increment ) [ NOT FOR REPLICATION ] ] ]
]
[ ROWGUIDCOL]
[ < column_constraint > ] [ ...n ]
< column_constraint > ::= [ CONSTRAINT constraint_name ]
{ [ NULL | NOT NULL ]
| [ { PRIMARY KEY | UNIQUE }
[ CLUSTERED | NONCLUSTERED ]
[ WITH FILLFACTOR = fillfactor ]
[ON {filegroup | DEFAULT} ] ]
]
| [ [ FOREIGN KEY ]
REFERENCES ref_table [ ( ref_column ) ]
[ ON DELETE { CASCADE | NO ACTION } ]
[ ON UPDATE { CASCADE | NO ACTION } ]
[ NOT FOR REPLICATION ]
]
| CHECK [ NOT FOR REPLICATION ]
( logical_expression )
}
< table_constraint > ::= [ CONSTRAINT constraint_name ]
{ [ { PRIMARY KEY | UNIQUE }
[ CLUSTERED | NONCLUSTERED ]
{ ( column [ ASC | DESC ] [ ,...n ] ) }
[ WITH FILLFACTOR = fillfactor ]
[ ON { filegroup | DEFAULT } ]
]
| FOREIGN KEY
[ ( column [ ,...n ] ) ]
REFERENCES ref_table [ ( ref_column [ ,...n ] ) ]
[ ON DELETE { CASCADE | NO ACTION } ]
[ ON UPDATE { CASCADE | NO ACTION } ]
[ NOT FOR REPLICATION ]
| CHECK [ NOT FOR REPLICATION ]
( search_conditions )
}
*/
/*
CREATE [ UNIQUE ] [ CLUSTERED | NONCLUSTERED ] INDEX index_name
ON { table | view } ( column [ ASC | DESC ] [ ,...n ] )
[ WITH < index_option > [ ,...n] ]
[ ON filegroup ]
< index_option > :: =
{ PAD_INDEX |
FILLFACTOR = fillfactor |
IGNORE_DUP_KEY |
DROP_EXISTING |
STATISTICS_NORECOMPUTE |
SORT_IN_TEMPDB
}
*/
function _IndexSQL($idxname, $tabname, $flds, $idxoptions)
{
$sql = array();
if ( isset($idxoptions['REPLACE']) || isset($idxoptions['DROP']) ) {
$sql[] = sprintf ($this->dropIndex, $idxname, $tabname);
if ( isset($idxoptions['DROP']) )
return $sql;
}
if ( empty ($flds) ) {
return $sql;
}
$unique = isset($idxoptions['UNIQUE']) ? ' UNIQUE' : '';
$clustered = isset($idxoptions['CLUSTERED']) ? ' CLUSTERED' : '';
if ( is_array($flds) )
$flds = implode(', ',$flds);
$s = 'CREATE' . $unique . $clustered . ' INDEX ' . $idxname . ' ON ' . $tabname . ' (' . $flds . ')';
if ( isset($idxoptions[$this->upperName]) )
$s .= $idxoptions[$this->upperName];
$sql[] = $s;
return $sql;
}
function _GetSize($ftype, $ty, $fsize, $fprec)
{
switch ($ftype) {
case 'INT':
case 'SMALLINT':
case 'TINYINT':
case 'BIGINT':
return $ftype;
}
if ($ty == 'T') return $ftype;
return parent::_GetSize($ftype, $ty, $fsize, $fprec);
}
}
PK P e" " " datadict/datadict-firebird.inc.phpnu W+A connection) ) {
return $name;
}
$quote = $this->connection->nameQuote;
// if name is of the form `name`, quote it
if ( preg_match('/^`(.+)`$/', $name, $matches) ) {
return $quote . $matches[1] . $quote;
}
// if name contains special characters, quote it
if ( !preg_match('/^[' . $this->nameRegex . ']+$/', $name) ) {
return $quote . $name . $quote;
}
return $quote . $name . $quote;
}
function CreateDatabase($dbname, $options=false)
{
$options = $this->_Options($options);
$sql = array();
$sql[] = "DECLARE EXTERNAL FUNCTION LOWER CSTRING(80) RETURNS CSTRING(80) FREE_IT ENTRY_POINT 'IB_UDF_lower' MODULE_NAME 'ib_udf'";
return $sql;
}
function _DropAutoIncrement($t)
{
if (strpos($t,'.') !== false) {
$tarr = explode('.',$t);
return 'DROP GENERATOR '.$tarr[0].'."gen_'.$tarr[1].'"';
}
return 'DROP GENERATOR "GEN_'.$t;
}
function _CreateSuffix($fname,&$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
$suffix = '';
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fnotnull) $suffix .= ' NOT NULL';
if ($fautoinc) $this->seqField = $fname;
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
/*
CREATE or replace TRIGGER jaddress_insert
before insert on jaddress
for each row
begin
IF ( NEW."seqField" IS NULL OR NEW."seqField" = 0 ) THEN
NEW."seqField" = GEN_ID("GEN_tabname", 1);
end;
*/
function _Triggers($tabname,$tableoptions)
{
if (!$this->seqField) return array();
$tab1 = preg_replace( '/"/', '', $tabname );
if ($this->schema) {
$t = strpos($tab1,'.');
if ($t !== false) $tab = substr($tab1,$t+1);
else $tab = $tab1;
$seqField = $this->seqField;
$seqname = $this->schema.'.'.$this->seqPrefix.$tab;
$trigname = $this->schema.'.trig_'.$this->seqPrefix.$tab;
} else {
$seqField = $this->seqField;
$seqname = $this->seqPrefix.$tab1;
$trigname = 'trig_'.$seqname;
}
if (isset($tableoptions['REPLACE']))
{ $sql[] = "DROP GENERATOR \"$seqname\"";
$sql[] = "CREATE GENERATOR \"$seqname\"";
$sql[] = "ALTER TRIGGER \"$trigname\" BEFORE INSERT OR UPDATE AS BEGIN IF ( NEW.$seqField IS NULL OR NEW.$seqField = 0 ) THEN NEW.$seqField = GEN_ID(\"$seqname\", 1); END";
}
else
{ $sql[] = "CREATE GENERATOR \"$seqname\"";
$sql[] = "CREATE TRIGGER \"$trigname\" FOR $tabname BEFORE INSERT OR UPDATE AS BEGIN IF ( NEW.$seqField IS NULL OR NEW.$seqField = 0 ) THEN NEW.$seqField = GEN_ID(\"$seqname\", 1); END";
}
$this->seqField = false;
return $sql;
}
}
PK PE> datadict/datadict-ibase.inc.phpnu W+A debug) ADOConnection::outp("AlterColumnSQL not supported");
return array();
}
function DropColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
if ($this->debug) ADOConnection::outp("DropColumnSQL not supported");
return array();
}
}
PK Pga,Rj j datadict/datadict-mysql.inc.phpnu W+A type;
$len = $fieldobj->max_length;
}
$is_serial = is_object($fieldobj) && $fieldobj->primary_key && $fieldobj->auto_increment;
$len = -1; // mysql max_length is not accurate
switch (strtoupper($t)) {
case 'STRING':
case 'CHAR':
case 'VARCHAR':
case 'TINYBLOB':
case 'TINYTEXT':
case 'ENUM':
case 'SET':
if ($len <= $this->blobSize) return 'C';
case 'TEXT':
case 'LONGTEXT':
case 'MEDIUMTEXT':
return 'X';
// php_mysql extension always returns 'blob' even if 'text'
// so we have to check whether binary...
case 'IMAGE':
case 'LONGBLOB':
case 'BLOB':
case 'MEDIUMBLOB':
return !empty($fieldobj->binary) ? 'B' : 'X';
case 'YEAR':
case 'DATE': return 'D';
case 'TIME':
case 'DATETIME':
case 'TIMESTAMP': return 'T';
case 'FLOAT':
case 'DOUBLE':
return 'F';
case 'INT':
case 'INTEGER': return $is_serial ? 'R' : 'I';
case 'TINYINT': return $is_serial ? 'R' : 'I1';
case 'SMALLINT': return $is_serial ? 'R' : 'I2';
case 'MEDIUMINT': return $is_serial ? 'R' : 'I4';
case 'BIGINT': return $is_serial ? 'R' : 'I8';
default: return 'N';
}
}
function ActualType($meta)
{
switch(strtoupper($meta)) {
case 'C': return 'VARCHAR';
case 'XL':return 'LONGTEXT';
case 'X': return 'TEXT';
case 'C2': return 'VARCHAR';
case 'X2': return 'LONGTEXT';
case 'B': return 'LONGBLOB';
case 'D': return 'DATE';
case 'TS':
case 'T': return 'DATETIME';
case 'L': return 'TINYINT';
case 'R':
case 'I4':
case 'I': return 'INTEGER';
case 'I1': return 'TINYINT';
case 'I2': return 'SMALLINT';
case 'I8': return 'BIGINT';
case 'F': return 'DOUBLE';
case 'N': return 'NUMERIC';
default:
return $meta;
}
}
// return string must begin with space
function _CreateSuffix($fname,&$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
$suffix = '';
if ($funsigned) $suffix .= ' UNSIGNED';
if ($fnotnull) $suffix .= ' NOT NULL';
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fautoinc) $suffix .= ' AUTO_INCREMENT';
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
/*
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name [(create_definition,...)]
[table_options] [select_statement]
create_definition:
col_name type [NOT NULL | NULL] [DEFAULT default_value] [AUTO_INCREMENT]
[PRIMARY KEY] [reference_definition]
or PRIMARY KEY (index_col_name,...)
or KEY [index_name] (index_col_name,...)
or INDEX [index_name] (index_col_name,...)
or UNIQUE [INDEX] [index_name] (index_col_name,...)
or FULLTEXT [INDEX] [index_name] (index_col_name,...)
or [CONSTRAINT symbol] FOREIGN KEY [index_name] (index_col_name,...)
[reference_definition]
or CHECK (expr)
*/
/*
CREATE [UNIQUE|FULLTEXT] INDEX index_name
ON tbl_name (col_name[(length)],... )
*/
function _IndexSQL($idxname, $tabname, $flds, $idxoptions)
{
$sql = array();
if ( isset($idxoptions['REPLACE']) || isset($idxoptions['DROP']) ) {
if ($this->alterTableAddIndex) $sql[] = "ALTER TABLE $tabname DROP INDEX $idxname";
else $sql[] = sprintf($this->dropIndex, $idxname, $tabname);
if ( isset($idxoptions['DROP']) )
return $sql;
}
if ( empty ($flds) ) {
return $sql;
}
if (isset($idxoptions['FULLTEXT'])) {
$unique = ' FULLTEXT';
} elseif (isset($idxoptions['UNIQUE'])) {
$unique = ' UNIQUE';
} else {
$unique = '';
}
if ( is_array($flds) ) $flds = implode(', ',$flds);
if ($this->alterTableAddIndex) $s = "ALTER TABLE $tabname ADD $unique INDEX $idxname ";
else $s = 'CREATE' . $unique . ' INDEX ' . $idxname . ' ON ' . $tabname;
$s .= ' (' . $flds . ')';
if ( isset($idxoptions[$this->upperName]) )
$s .= $idxoptions[$this->upperName];
$sql[] = $s;
return $sql;
}
}
PK PJ datadict/datadict-sybase.inc.phpnu W+A type;
$len = $fieldobj->max_length;
}
$len = -1; // mysql max_length is not accurate
switch (strtoupper($t)) {
case 'INT':
case 'INTEGER': return 'I';
case 'BIT':
case 'TINYINT': return 'I1';
case 'SMALLINT': return 'I2';
case 'BIGINT': return 'I8';
case 'REAL':
case 'FLOAT': return 'F';
default: return parent::MetaType($t,$len,$fieldobj);
}
}
function ActualType($meta)
{
switch(strtoupper($meta)) {
case 'C': return 'VARCHAR';
case 'XL':
case 'X': return 'TEXT';
case 'C2': return 'NVARCHAR';
case 'X2': return 'NTEXT';
case 'B': return 'IMAGE';
case 'D': return 'DATETIME';
case 'TS':
case 'T': return 'DATETIME';
case 'L': return 'BIT';
case 'I': return 'INT';
case 'I1': return 'TINYINT';
case 'I2': return 'SMALLINT';
case 'I4': return 'INT';
case 'I8': return 'BIGINT';
case 'F': return 'REAL';
case 'N': return 'NUMERIC';
default:
return $meta;
}
}
function AddColumnSQL($tabname, $flds)
{
$tabname = $this->TableName ($tabname);
$f = array();
list($lines,$pkey) = $this->_GenFields($flds);
$s = "ALTER TABLE $tabname $this->addCol";
foreach($lines as $v) {
$f[] = "\n $v";
}
$s .= implode(', ',$f);
$sql[] = $s;
return $sql;
}
function AlterColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
$tabname = $this->TableName ($tabname);
$sql = array();
list($lines,$pkey) = $this->_GenFields($flds);
foreach($lines as $v) {
$sql[] = "ALTER TABLE $tabname $this->alterCol $v";
}
return $sql;
}
function DropColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
$tabname = $this->TableName($tabname);
if (!is_array($flds)) $flds = explode(',',$flds);
$f = array();
$s = "ALTER TABLE $tabname";
foreach($flds as $v) {
$f[] = "\n$this->dropCol ".$this->NameQuote($v);
}
$s .= implode(', ',$f);
$sql[] = $s;
return $sql;
}
// return string must begin with space
function _CreateSuffix($fname,&$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
$suffix = '';
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fautoinc) $suffix .= ' DEFAULT AUTOINCREMENT';
if ($fnotnull) $suffix .= ' NOT NULL';
else if ($suffix == '') $suffix .= ' NULL';
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
/*
CREATE TABLE
[ database_name.[ owner ] . | owner. ] table_name
( { < column_definition >
| column_name AS computed_column_expression
| < table_constraint > ::= [ CONSTRAINT constraint_name ] }
| [ { PRIMARY KEY | UNIQUE } [ ,...n ]
)
[ ON { filegroup | DEFAULT } ]
[ TEXTIMAGE_ON { filegroup | DEFAULT } ]
< column_definition > ::= { column_name data_type }
[ COLLATE < collation_name > ]
[ [ DEFAULT constant_expression ]
| [ IDENTITY [ ( seed , increment ) [ NOT FOR REPLICATION ] ] ]
]
[ ROWGUIDCOL]
[ < column_constraint > ] [ ...n ]
< column_constraint > ::= [ CONSTRAINT constraint_name ]
{ [ NULL | NOT NULL ]
| [ { PRIMARY KEY | UNIQUE }
[ CLUSTERED | NONCLUSTERED ]
[ WITH FILLFACTOR = fillfactor ]
[ON {filegroup | DEFAULT} ] ]
]
| [ [ FOREIGN KEY ]
REFERENCES ref_table [ ( ref_column ) ]
[ ON DELETE { CASCADE | NO ACTION } ]
[ ON UPDATE { CASCADE | NO ACTION } ]
[ NOT FOR REPLICATION ]
]
| CHECK [ NOT FOR REPLICATION ]
( logical_expression )
}
< table_constraint > ::= [ CONSTRAINT constraint_name ]
{ [ { PRIMARY KEY | UNIQUE }
[ CLUSTERED | NONCLUSTERED ]
{ ( column [ ASC | DESC ] [ ,...n ] ) }
[ WITH FILLFACTOR = fillfactor ]
[ ON { filegroup | DEFAULT } ]
]
| FOREIGN KEY
[ ( column [ ,...n ] ) ]
REFERENCES ref_table [ ( ref_column [ ,...n ] ) ]
[ ON DELETE { CASCADE | NO ACTION } ]
[ ON UPDATE { CASCADE | NO ACTION } ]
[ NOT FOR REPLICATION ]
| CHECK [ NOT FOR REPLICATION ]
( search_conditions )
}
*/
/*
CREATE [ UNIQUE ] [ CLUSTERED | NONCLUSTERED ] INDEX index_name
ON { table | view } ( column [ ASC | DESC ] [ ,...n ] )
[ WITH < index_option > [ ,...n] ]
[ ON filegroup ]
< index_option > :: =
{ PAD_INDEX |
FILLFACTOR = fillfactor |
IGNORE_DUP_KEY |
DROP_EXISTING |
STATISTICS_NORECOMPUTE |
SORT_IN_TEMPDB
}
*/
function _IndexSQL($idxname, $tabname, $flds, $idxoptions)
{
$sql = array();
if ( isset($idxoptions['REPLACE']) || isset($idxoptions['DROP']) ) {
$sql[] = sprintf ($this->dropIndex, $idxname, $tabname);
if ( isset($idxoptions['DROP']) )
return $sql;
}
if ( empty ($flds) ) {
return $sql;
}
$unique = isset($idxoptions['UNIQUE']) ? ' UNIQUE' : '';
$clustered = isset($idxoptions['CLUSTERED']) ? ' CLUSTERED' : '';
if ( is_array($flds) )
$flds = implode(', ',$flds);
$s = 'CREATE' . $unique . $clustered . ' INDEX ' . $idxname . ' ON ' . $tabname . ' (' . $flds . ')';
if ( isset($idxoptions[$this->upperName]) )
$s .= $idxoptions[$this->upperName];
$sql[] = $s;
return $sql;
}
}
PK PU
U
! datadict/datadict-generic.inc.phpnu W+A debug) ADOConnection::outp("AlterColumnSQL not supported");
return array();
}
function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
if ($this->debug) ADOConnection::outp("DropColumnSQL not supported");
return array();
}
}
/*
//db2
function ActualType($meta)
{
switch($meta) {
case 'C': return 'VARCHAR';
case 'X': return 'VARCHAR';
case 'C2': return 'VARCHAR'; // up to 32K
case 'X2': return 'VARCHAR';
case 'B': return 'BLOB';
case 'D': return 'DATE';
case 'T': return 'TIMESTAMP';
case 'L': return 'SMALLINT';
case 'I': return 'INTEGER';
case 'I1': return 'SMALLINT';
case 'I2': return 'SMALLINT';
case 'I4': return 'INTEGER';
case 'I8': return 'BIGINT';
case 'F': return 'DOUBLE';
case 'N': return 'DECIMAL';
default:
return $meta;
}
}
// ifx
function ActualType($meta)
{
switch($meta) {
case 'C': return 'VARCHAR';// 255
case 'X': return 'TEXT';
case 'C2': return 'NVARCHAR';
case 'X2': return 'TEXT';
case 'B': return 'BLOB';
case 'D': return 'DATE';
case 'T': return 'DATETIME';
case 'L': return 'SMALLINT';
case 'I': return 'INTEGER';
case 'I1': return 'SMALLINT';
case 'I2': return 'SMALLINT';
case 'I4': return 'INTEGER';
case 'I8': return 'DECIMAL(20)';
case 'F': return 'FLOAT';
case 'N': return 'DECIMAL';
default:
return $meta;
}
}
*/
PK P<> <> " datadict/datadict-postgres.inc.phpnu W+A type;
$len = $fieldobj->max_length;
}
$is_serial = is_object($fieldobj) && !empty($fieldobj->primary_key) && !empty($fieldobj->unique) &&
!empty($fieldobj->has_default) && substr($fieldobj->default_value,0,8) == 'nextval(';
switch (strtoupper($t)) {
case 'INTERVAL':
case 'CHAR':
case 'CHARACTER':
case 'VARCHAR':
case 'NAME':
case 'BPCHAR':
if ($len <= $this->blobSize) return 'C';
case 'TEXT':
return 'X';
case 'IMAGE': // user defined type
case 'BLOB': // user defined type
case 'BIT': // This is a bit string, not a single bit, so don't return 'L'
case 'VARBIT':
case 'BYTEA':
return 'B';
case 'BOOL':
case 'BOOLEAN':
return 'L';
case 'DATE':
return 'D';
case 'TIME':
case 'DATETIME':
case 'TIMESTAMP':
case 'TIMESTAMPTZ':
return 'T';
case 'INTEGER': return !$is_serial ? 'I' : 'R';
case 'SMALLINT':
case 'INT2': return !$is_serial ? 'I2' : 'R';
case 'INT4': return !$is_serial ? 'I4' : 'R';
case 'BIGINT':
case 'INT8': return !$is_serial ? 'I8' : 'R';
case 'OID':
case 'SERIAL':
return 'R';
case 'FLOAT4':
case 'FLOAT8':
case 'DOUBLE PRECISION':
case 'REAL':
return 'F';
default:
return 'N';
}
}
function ActualType($meta)
{
switch($meta) {
case 'C': return 'VARCHAR';
case 'XL':
case 'X': return 'TEXT';
case 'C2': return 'VARCHAR';
case 'X2': return 'TEXT';
case 'B': return 'BYTEA';
case 'D': return 'DATE';
case 'TS':
case 'T': return 'TIMESTAMP';
case 'L': return 'BOOLEAN';
case 'I': return 'INTEGER';
case 'I1': return 'SMALLINT';
case 'I2': return 'INT2';
case 'I4': return 'INT4';
case 'I8': return 'INT8';
case 'F': return 'FLOAT8';
case 'N': return 'NUMERIC';
default:
return $meta;
}
}
/**
* Adding a new Column
*
* reimplementation of the default function as postgres does NOT allow to set the default in the same statement
*
* @param string $tabname table-name
* @param string $flds column-names and types for the changed columns
* @return array with SQL strings
*/
function AddColumnSQL($tabname, $flds)
{
$tabname = $this->TableName ($tabname);
$sql = array();
$not_null = false;
list($lines,$pkey) = $this->_GenFields($flds);
$alter = 'ALTER TABLE ' . $tabname . $this->addCol . ' ';
foreach($lines as $v) {
if (($not_null = preg_match('/NOT NULL/i',$v))) {
$v = preg_replace('/NOT NULL/i','',$v);
}
if (preg_match('/^([^ ]+) .*DEFAULT (\'[^\']+\'|\"[^\"]+\"|[^ ]+)/',$v,$matches)) {
list(,$colname,$default) = $matches;
$sql[] = $alter . str_replace('DEFAULT '.$default,'',$v);
$sql[] = 'UPDATE '.$tabname.' SET '.$colname.'='.$default;
$sql[] = 'ALTER TABLE '.$tabname.' ALTER COLUMN '.$colname.' SET DEFAULT ' . $default;
} else {
$sql[] = $alter . $v;
}
if ($not_null) {
list($colname) = explode(' ',$v);
$sql[] = 'ALTER TABLE '.$tabname.' ALTER COLUMN '.$colname.' SET NOT NULL';
}
}
return $sql;
}
function DropIndexSQL ($idxname, $tabname = NULL)
{
return array(sprintf($this->dropIndex, $this->TableName($idxname), $this->TableName($tabname)));
}
/**
* Change the definition of one column
*
* Postgres can't do that on it's own, you need to supply the complete defintion of the new table,
* to allow, recreating the table and copying the content over to the new table
* @param string $tabname table-name
* @param string $flds column-name and type for the changed column
* @param string $tableflds complete defintion of the new table, eg. for postgres, default ''
* @param array/ $tableoptions options for the new table see CreateTableSQL, default ''
* @return array with SQL strings
*/
/*
function AlterColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
if (!$tableflds) {
if ($this->debug) ADOConnection::outp("AlterColumnSQL needs a complete table-definiton for PostgreSQL");
return array();
}
return $this->_recreate_copy_table($tabname,False,$tableflds,$tableoptions);
}*/
function AlterColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
// Check if alter single column datatype available - works with 8.0+
$has_alter_column = 8.0 <= (float) @$this->serverInfo['version'];
if ($has_alter_column) {
$tabname = $this->TableName($tabname);
$sql = array();
list($lines,$pkey) = $this->_GenFields($flds);
$set_null = false;
foreach($lines as $v) {
$alter = 'ALTER TABLE ' . $tabname . $this->alterCol . ' ';
if ($not_null = preg_match('/NOT NULL/i',$v)) {
$v = preg_replace('/NOT NULL/i','',$v);
}
// this next block doesn't work - there is no way that I can see to
// explicitly ask a column to be null using $flds
else if ($set_null = preg_match('/NULL/i',$v)) {
// if they didn't specify not null, see if they explicitely asked for null
// Lookbehind pattern covers the case 'fieldname NULL datatype DEFAULT NULL'
// only the first NULL should be removed, not the one specifying
// the default value
$v = preg_replace('/(?MetaColumns($tabname);
list(,$colname,$default) = $matches;
$alter .= $colname;
if ($this->connection) {
$old_coltype = $this->connection->MetaType($existing[strtoupper($colname)]);
}
else {
$old_coltype = $t;
}
$v = preg_replace('/^' . preg_quote($colname) . '\s/', '', $v);
$t = trim(str_replace('DEFAULT '.$default,'',$v));
// Type change from bool to int
if ( $old_coltype == 'L' && $t == 'INTEGER' ) {
$sql[] = $alter . ' DROP DEFAULT';
$sql[] = $alter . " TYPE $t USING ($colname::BOOL)::INT";
$sql[] = $alter . " SET DEFAULT $default";
}
// Type change from int to bool
else if ( $old_coltype == 'I' && $t == 'BOOLEAN' ) {
if( strcasecmp('NULL', trim($default)) != 0 ) {
$default = $this->connection->qstr($default);
}
$sql[] = $alter . ' DROP DEFAULT';
$sql[] = $alter . " TYPE $t USING CASE WHEN $colname = 0 THEN false ELSE true END";
$sql[] = $alter . " SET DEFAULT $default";
}
// Any other column types conversion
else {
$sql[] = $alter . " TYPE $t";
$sql[] = $alter . " SET DEFAULT $default";
}
}
else {
// drop default?
preg_match ('/^\s*(\S+)\s+(.*)$/',$v,$matches);
list (,$colname,$rest) = $matches;
$alter .= $colname;
$sql[] = $alter . ' TYPE ' . $rest;
}
# list($colname) = explode(' ',$v);
if ($not_null) {
// this does not error out if the column is already not null
$sql[] = $alter . ' SET NOT NULL';
}
if ($set_null) {
// this does not error out if the column is already null
$sql[] = $alter . ' DROP NOT NULL';
}
}
return $sql;
}
// does not have alter column
if (!$tableflds) {
if ($this->debug) ADOConnection::outp("AlterColumnSQL needs a complete table-definiton for PostgreSQL");
return array();
}
return $this->_recreate_copy_table($tabname,False,$tableflds,$tableoptions);
}
/**
* Drop one column
*
* Postgres < 7.3 can't do that on it's own, you need to supply the complete defintion of the new table,
* to allow, recreating the table and copying the content over to the new table
* @param string $tabname table-name
* @param string $flds column-name and type for the changed column
* @param string $tableflds complete defintion of the new table, eg. for postgres, default ''
* @param array/ $tableoptions options for the new table see CreateTableSQL, default ''
* @return array with SQL strings
*/
function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
$has_drop_column = 7.3 <= (float) @$this->serverInfo['version'];
if (!$has_drop_column && !$tableflds) {
if ($this->debug) ADOConnection::outp("DropColumnSQL needs complete table-definiton for PostgreSQL < 7.3");
return array();
}
if ($has_drop_column) {
return ADODB_DataDict::DropColumnSQL($tabname, $flds);
}
return $this->_recreate_copy_table($tabname,$flds,$tableflds,$tableoptions);
}
/**
* Save the content into a temp. table, drop and recreate the original table and copy the content back in
*
* We also take care to set the values of the sequenz and recreate the indexes.
* All this is done in a transaction, to not loose the content of the table, if something went wrong!
* @internal
* @param string $tabname table-name
* @param string $dropflds column-names to drop
* @param string $tableflds complete defintion of the new table, eg. for postgres
* @param array/string $tableoptions options for the new table see CreateTableSQL, default ''
* @return array with SQL strings
*/
function _recreate_copy_table($tabname,$dropflds,$tableflds,$tableoptions='')
{
if ($dropflds && !is_array($dropflds)) $dropflds = explode(',',$dropflds);
$copyflds = array();
foreach($this->MetaColumns($tabname) as $fld) {
if (!$dropflds || !in_array($fld->name,$dropflds)) {
// we need to explicit convert varchar to a number to be able to do an AlterColumn of a char column to a nummeric one
if (preg_match('/'.$fld->name.' (I|I2|I4|I8|N|F)/i',$tableflds,$matches) &&
in_array($fld->type,array('varchar','char','text','bytea'))) {
$copyflds[] = "to_number($fld->name,'S9999999999999D99')";
} else {
$copyflds[] = $fld->name;
}
// identify the sequence name and the fld its on
if ($fld->primary_key && $fld->has_default &&
preg_match("/nextval\('([^']+)'::text\)/",$fld->default_value,$matches)) {
$seq_name = $matches[1];
$seq_fld = $fld->name;
}
}
}
$copyflds = implode(', ',$copyflds);
$tempname = $tabname.'_tmp';
$aSql[] = 'BEGIN'; // we use a transaction, to make sure not to loose the content of the table
$aSql[] = "SELECT * INTO TEMPORARY TABLE $tempname FROM $tabname";
$aSql = array_merge($aSql,$this->DropTableSQL($tabname));
$aSql = array_merge($aSql,$this->CreateTableSQL($tabname,$tableflds,$tableoptions));
$aSql[] = "INSERT INTO $tabname SELECT $copyflds FROM $tempname";
if ($seq_name && $seq_fld) { // if we have a sequence we need to set it again
$seq_name = $tabname.'_'.$seq_fld.'_seq'; // has to be the name of the new implicit sequence
$aSql[] = "SELECT setval('$seq_name',MAX($seq_fld)) FROM $tabname";
}
$aSql[] = "DROP TABLE $tempname";
// recreate the indexes, if they not contain one of the droped columns
foreach($this->MetaIndexes($tabname) as $idx_name => $idx_data)
{
if (substr($idx_name,-5) != '_pkey' && (!$dropflds || !count(array_intersect($dropflds,$idx_data['columns'])))) {
$aSql = array_merge($aSql,$this->CreateIndexSQL($idx_name,$tabname,$idx_data['columns'],
$idx_data['unique'] ? array('UNIQUE') : False));
}
}
$aSql[] = 'COMMIT';
return $aSql;
}
function DropTableSQL($tabname)
{
$sql = ADODB_DataDict::DropTableSQL($tabname);
$drop_seq = $this->_DropAutoIncrement($tabname);
if ($drop_seq) $sql[] = $drop_seq;
return $sql;
}
// return string must begin with space
function _CreateSuffix($fname, &$ftype, $fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
if ($fautoinc) {
$ftype = 'SERIAL';
return '';
}
$suffix = '';
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fnotnull) $suffix .= ' NOT NULL';
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
// search for a sequece for the given table (asumes the seqence-name contains the table-name!)
// if yes return sql to drop it
// this is still necessary if postgres < 7.3 or the SERIAL was created on an earlier version!!!
function _DropAutoIncrement($tabname)
{
$tabname = $this->connection->quote('%'.$tabname.'%');
$seq = $this->connection->GetOne("SELECT relname FROM pg_class WHERE NOT relname ~ 'pg_.*' AND relname LIKE $tabname AND relkind='S'");
// check if a tables depends on the sequenz and it therefor cant and dont need to be droped separatly
if (!$seq || $this->connection->GetOne("SELECT relname FROM pg_class JOIN pg_depend ON pg_class.relfilenode=pg_depend.objid WHERE relname='$seq' AND relkind='S' AND deptype='i'")) {
return False;
}
return "DROP SEQUENCE ".$seq;
}
function RenameTableSQL($tabname,$newname)
{
if (!empty($this->schema)) {
$rename_from = $this->TableName($tabname);
$schema_save = $this->schema;
$this->schema = false;
$rename_to = $this->TableName($newname);
$this->schema = $schema_save;
return array (sprintf($this->renameTable, $rename_from, $rename_to));
}
return array (sprintf($this->renameTable, $this->TableName($tabname),$this->TableName($newname)));
}
/*
CREATE [ [ LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name (
{ column_name data_type [ DEFAULT default_expr ] [ column_constraint [, ... ] ]
| table_constraint } [, ... ]
)
[ INHERITS ( parent_table [, ... ] ) ]
[ WITH OIDS | WITHOUT OIDS ]
where column_constraint is:
[ CONSTRAINT constraint_name ]
{ NOT NULL | NULL | UNIQUE | PRIMARY KEY |
CHECK (expression) |
REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL ]
[ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
and table_constraint is:
[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] ) |
PRIMARY KEY ( column_name [, ... ] ) |
CHECK ( expression ) |
FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ]
[ MATCH FULL | MATCH PARTIAL ] [ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]
*/
/*
CREATE [ UNIQUE ] INDEX index_name ON table
[ USING acc_method ] ( column [ ops_name ] [, ...] )
[ WHERE predicate ]
CREATE [ UNIQUE ] INDEX index_name ON table
[ USING acc_method ] ( func_name( column [, ... ]) [ ops_name ] )
[ WHERE predicate ]
*/
function _IndexSQL($idxname, $tabname, $flds, $idxoptions)
{
$sql = array();
if ( isset($idxoptions['REPLACE']) || isset($idxoptions['DROP']) ) {
$sql[] = sprintf ($this->dropIndex, $idxname, $tabname);
if ( isset($idxoptions['DROP']) )
return $sql;
}
if ( empty ($flds) ) {
return $sql;
}
$unique = isset($idxoptions['UNIQUE']) ? ' UNIQUE' : '';
$s = 'CREATE' . $unique . ' INDEX ' . $idxname . ' ON ' . $tabname . ' ';
if (isset($idxoptions['HASH']))
$s .= 'USING HASH ';
if ( isset($idxoptions[$this->upperName]) )
$s .= $idxoptions[$this->upperName];
if ( is_array($flds) )
$flds = implode(', ',$flds);
$s .= '(' . $flds . ')';
$sql[] = $s;
return $sql;
}
function _GetSize($ftype, $ty, $fsize, $fprec)
{
if (strlen($fsize) && $ty != 'X' && $ty != 'B' && $ty != 'I' && strpos($ftype,'(') === false) {
$ftype .= "(".$fsize;
if (strlen($fprec)) $ftype .= ",".$fprec;
$ftype .= ')';
}
return $ftype;
}
}
PK Pu datadict/datadict-db2.inc.phpnu W+A debug) ADOConnection::outp("AlterColumnSQL not supported");
return array();
}
function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
if ($this->debug) ADOConnection::outp("DropColumnSQL not supported");
return array();
}
function ChangeTableSQL($tablename, $flds, $tableoptions = false)
{
/**
Allow basic table changes to DB2 databases
DB2 will fatally reject changes to non character columns
*/
$validTypes = array("CHAR","VARC");
$invalidTypes = array("BIGI","BLOB","CLOB","DATE", "DECI","DOUB", "INTE", "REAL","SMAL", "TIME");
// check table exists
$cols = $this->MetaColumns($tablename);
if ( empty($cols)) {
return $this->CreateTableSQL($tablename, $flds, $tableoptions);
}
// already exists, alter table instead
list($lines,$pkey) = $this->_GenFields($flds);
$alter = 'ALTER TABLE ' . $this->TableName($tablename);
$sql = array();
foreach ( $lines as $id => $v ) {
if ( isset($cols[$id]) && is_object($cols[$id]) ) {
/**
If the first field of $v is the fieldname, and
the second is the field type/size, we assume its an
attempt to modify the column size, so check that it is allowed
$v can have an indeterminate number of blanks between the
fields, so account for that too
*/
$vargs = explode(' ' , $v);
// assume that $vargs[0] is the field name.
$i=0;
// Find the next non-blank value;
for ($i=1;$ialterCol . ' ' . $v;
} else {
$sql[] = $alter . $this->addCol . ' ' . $v;
}
}
return $sql;
}
}
PK P`8 datadict/datadict-sapdb.inc.phpnu W+A type;
$len = $fieldobj->max_length;
}
static $maxdb_type2adodb = array(
'VARCHAR' => 'C',
'CHARACTER' => 'C',
'LONG' => 'X', // no way to differ between 'X' and 'B' :-(
'DATE' => 'D',
'TIMESTAMP' => 'T',
'BOOLEAN' => 'L',
'INTEGER' => 'I4',
'SMALLINT' => 'I2',
'FLOAT' => 'F',
'FIXED' => 'N',
);
$type = isset($maxdb_type2adodb[$t]) ? $maxdb_type2adodb[$t] : 'C';
// convert integer-types simulated with fixed back to integer
if ($t == 'FIXED' && !$fieldobj->scale && ($len == 20 || $len == 3)) {
$type = $len == 20 ? 'I8' : 'I1';
}
if ($fieldobj->auto_increment) $type = 'R';
return $type;
}
// return string must begin with space
function _CreateSuffix($fname,&$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
$suffix = '';
if ($funsigned) $suffix .= ' UNSIGNED';
if ($fnotnull) $suffix .= ' NOT NULL';
if ($fautoinc) $suffix .= ' DEFAULT SERIAL';
elseif (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
function AddColumnSQL($tabname, $flds)
{
$tabname = $this->TableName ($tabname);
$sql = array();
list($lines,$pkey) = $this->_GenFields($flds);
return array( 'ALTER TABLE ' . $tabname . ' ADD (' . implode(', ',$lines) . ')' );
}
function AlterColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
$tabname = $this->TableName ($tabname);
$sql = array();
list($lines,$pkey) = $this->_GenFields($flds);
return array( 'ALTER TABLE ' . $tabname . ' MODIFY (' . implode(', ',$lines) . ')' );
}
function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
$tabname = $this->TableName ($tabname);
if (!is_array($flds)) $flds = explode(',',$flds);
foreach($flds as $k => $v) {
$flds[$k] = $this->NameQuote($v);
}
return array( 'ALTER TABLE ' . $tabname . ' DROP (' . implode(', ',$flds) . ')' );
}
}
PK P.J J datadict/datadict-mssql.inc.phpnu W+A type;
$len = $fieldobj->max_length;
}
$len = -1; // mysql max_length is not accurate
switch (strtoupper($t)) {
case 'R':
case 'INT':
case 'INTEGER': return 'I';
case 'BIT':
case 'TINYINT': return 'I1';
case 'SMALLINT': return 'I2';
case 'BIGINT': return 'I8';
case 'SMALLDATETIME': return 'T';
case 'REAL':
case 'FLOAT': return 'F';
default: return parent::MetaType($t,$len,$fieldobj);
}
}
function ActualType($meta)
{
switch(strtoupper($meta)) {
case 'C': return 'VARCHAR';
case 'XL': return (isset($this)) ? $this->typeXL : 'TEXT';
case 'X': return (isset($this)) ? $this->typeX : 'TEXT'; ## could be varchar(8000), but we want compat with oracle
case 'C2': return 'NVARCHAR';
case 'X2': return 'NTEXT';
case 'B': return 'IMAGE';
case 'D': return 'DATETIME';
case 'TS':
case 'T': return 'DATETIME';
case 'L': return 'BIT';
case 'R':
case 'I': return 'INT';
case 'I1': return 'TINYINT';
case 'I2': return 'SMALLINT';
case 'I4': return 'INT';
case 'I8': return 'BIGINT';
case 'F': return 'REAL';
case 'N': return 'NUMERIC';
default:
return $meta;
}
}
function AddColumnSQL($tabname, $flds)
{
$tabname = $this->TableName ($tabname);
$f = array();
list($lines,$pkey) = $this->_GenFields($flds);
$s = "ALTER TABLE $tabname $this->addCol";
foreach($lines as $v) {
$f[] = "\n $v";
}
$s .= implode(', ',$f);
$sql[] = $s;
return $sql;
}
/*
function AlterColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
$tabname = $this->TableName ($tabname);
$sql = array();
list($lines,$pkey) = $this->_GenFields($flds);
foreach($lines as $v) {
$sql[] = "ALTER TABLE $tabname $this->alterCol $v";
}
return $sql;
}
*/
function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
$tabname = $this->TableName ($tabname);
if (!is_array($flds))
$flds = explode(',',$flds);
$f = array();
$s = 'ALTER TABLE ' . $tabname;
foreach($flds as $v) {
$f[] = "\n$this->dropCol ".$this->NameQuote($v);
}
$s .= implode(', ',$f);
$sql[] = $s;
return $sql;
}
// return string must begin with space
function _CreateSuffix($fname,&$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
$suffix = '';
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fautoinc) $suffix .= ' IDENTITY(1,1)';
if ($fnotnull) $suffix .= ' NOT NULL';
else if ($suffix == '') $suffix .= ' NULL';
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
/*
CREATE TABLE
[ database_name.[ owner ] . | owner. ] table_name
( { < column_definition >
| column_name AS computed_column_expression
| < table_constraint > ::= [ CONSTRAINT constraint_name ] }
| [ { PRIMARY KEY | UNIQUE } [ ,...n ]
)
[ ON { filegroup | DEFAULT } ]
[ TEXTIMAGE_ON { filegroup | DEFAULT } ]
< column_definition > ::= { column_name data_type }
[ COLLATE < collation_name > ]
[ [ DEFAULT constant_expression ]
| [ IDENTITY [ ( seed , increment ) [ NOT FOR REPLICATION ] ] ]
]
[ ROWGUIDCOL]
[ < column_constraint > ] [ ...n ]
< column_constraint > ::= [ CONSTRAINT constraint_name ]
{ [ NULL | NOT NULL ]
| [ { PRIMARY KEY | UNIQUE }
[ CLUSTERED | NONCLUSTERED ]
[ WITH FILLFACTOR = fillfactor ]
[ON {filegroup | DEFAULT} ] ]
]
| [ [ FOREIGN KEY ]
REFERENCES ref_table [ ( ref_column ) ]
[ ON DELETE { CASCADE | NO ACTION } ]
[ ON UPDATE { CASCADE | NO ACTION } ]
[ NOT FOR REPLICATION ]
]
| CHECK [ NOT FOR REPLICATION ]
( logical_expression )
}
< table_constraint > ::= [ CONSTRAINT constraint_name ]
{ [ { PRIMARY KEY | UNIQUE }
[ CLUSTERED | NONCLUSTERED ]
{ ( column [ ASC | DESC ] [ ,...n ] ) }
[ WITH FILLFACTOR = fillfactor ]
[ ON { filegroup | DEFAULT } ]
]
| FOREIGN KEY
[ ( column [ ,...n ] ) ]
REFERENCES ref_table [ ( ref_column [ ,...n ] ) ]
[ ON DELETE { CASCADE | NO ACTION } ]
[ ON UPDATE { CASCADE | NO ACTION } ]
[ NOT FOR REPLICATION ]
| CHECK [ NOT FOR REPLICATION ]
( search_conditions )
}
*/
/*
CREATE [ UNIQUE ] [ CLUSTERED | NONCLUSTERED ] INDEX index_name
ON { table | view } ( column [ ASC | DESC ] [ ,...n ] )
[ WITH < index_option > [ ,...n] ]
[ ON filegroup ]
< index_option > :: =
{ PAD_INDEX |
FILLFACTOR = fillfactor |
IGNORE_DUP_KEY |
DROP_EXISTING |
STATISTICS_NORECOMPUTE |
SORT_IN_TEMPDB
}
*/
function _IndexSQL($idxname, $tabname, $flds, $idxoptions)
{
$sql = array();
if ( isset($idxoptions['REPLACE']) || isset($idxoptions['DROP']) ) {
$sql[] = sprintf ($this->dropIndex, $idxname, $tabname);
if ( isset($idxoptions['DROP']) )
return $sql;
}
if ( empty ($flds) ) {
return $sql;
}
$unique = isset($idxoptions['UNIQUE']) ? ' UNIQUE' : '';
$clustered = isset($idxoptions['CLUSTERED']) ? ' CLUSTERED' : '';
if ( is_array($flds) )
$flds = implode(', ',$flds);
$s = 'CREATE' . $unique . $clustered . ' INDEX ' . $idxname . ' ON ' . $tabname . ' (' . $flds . ')';
if ( isset($idxoptions[$this->upperName]) )
$s .= $idxoptions[$this->upperName];
$sql[] = $s;
return $sql;
}
function _GetSize($ftype, $ty, $fsize, $fprec)
{
switch ($ftype) {
case 'INT':
case 'SMALLINT':
case 'TINYINT':
case 'BIGINT':
return $ftype;
}
if ($ty == 'T') return $ftype;
return parent::_GetSize($ftype, $ty, $fsize, $fprec);
}
}
PK PSr r datadict/datadict-access.inc.phpnu W+A debug) ADOConnection::outp("Warning: Access does not supported DEFAULT values (field $fname)");
}
if ($fnotnull) $suffix .= ' NOT NULL';
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
function CreateDatabase($dbname,$options=false)
{
return array();
}
function SetSchema($schema)
{
}
function AlterColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
if ($this->debug) ADOConnection::outp("AlterColumnSQL not supported");
return array();
}
function DropColumnSQL($tabname, $flds, $tableflds='',$tableoptions='')
{
if ($this->debug) ADOConnection::outp("DropColumnSQL not supported");
return array();
}
}
PK P'
datadict/datadict-oci8.inc.phpnu W+A type;
$len = $fieldobj->max_length;
}
switch (strtoupper($t)) {
case 'VARCHAR':
case 'VARCHAR2':
case 'CHAR':
case 'VARBINARY':
case 'BINARY':
if (isset($this) && $len <= $this->blobSize) return 'C';
return 'X';
case 'NCHAR':
case 'NVARCHAR2':
case 'NVARCHAR':
if (isset($this) && $len <= $this->blobSize) return 'C2';
return 'X2';
case 'NCLOB':
case 'CLOB':
return 'XL';
case 'LONG RAW':
case 'LONG VARBINARY':
case 'BLOB':
return 'B';
case 'TIMESTAMP':
return 'TS';
case 'DATE':
return 'T';
case 'INT':
case 'SMALLINT':
case 'INTEGER':
return 'I';
default:
return 'N';
}
}
function ActualType($meta)
{
switch($meta) {
case 'C': return 'VARCHAR';
case 'X': return $this->typeX;
case 'XL': return $this->typeXL;
case 'C2': return 'NVARCHAR2';
case 'X2': return 'NVARCHAR2(4000)';
case 'B': return 'BLOB';
case 'TS':
return 'TIMESTAMP';
case 'D':
case 'T': return 'DATE';
case 'L': return 'NUMBER(1)';
case 'I1': return 'NUMBER(3)';
case 'I2': return 'NUMBER(5)';
case 'I':
case 'I4': return 'NUMBER(10)';
case 'I8': return 'NUMBER(20)';
case 'F': return 'NUMBER';
case 'N': return 'NUMBER';
case 'R': return 'NUMBER(20)';
default:
return $meta;
}
}
function CreateDatabase($dbname, $options=false)
{
$options = $this->_Options($options);
$password = isset($options['PASSWORD']) ? $options['PASSWORD'] : 'tiger';
$tablespace = isset($options["TABLESPACE"]) ? " DEFAULT TABLESPACE ".$options["TABLESPACE"] : '';
$sql[] = "CREATE USER ".$dbname." IDENTIFIED BY ".$password.$tablespace;
$sql[] = "GRANT CREATE SESSION, CREATE TABLE,UNLIMITED TABLESPACE,CREATE SEQUENCE TO $dbname";
return $sql;
}
function AddColumnSQL($tabname, $flds)
{
$tabname = $this->TableName($tabname);
$f = array();
list($lines,$pkey) = $this->_GenFields($flds);
$s = "ALTER TABLE $tabname ADD (";
foreach($lines as $v) {
$f[] = "\n $v";
}
$s .= implode(', ',$f).')';
$sql[] = $s;
return $sql;
}
function AlterColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
$tabname = $this->TableName($tabname);
$f = array();
list($lines,$pkey) = $this->_GenFields($flds);
$s = "ALTER TABLE $tabname MODIFY(";
foreach($lines as $v) {
$f[] = "\n $v";
}
$s .= implode(', ',$f).')';
$sql[] = $s;
return $sql;
}
function DropColumnSQL($tabname, $flds, $tableflds='', $tableoptions='')
{
if (!is_array($flds)) $flds = explode(',',$flds);
foreach ($flds as $k => $v) $flds[$k] = $this->NameQuote($v);
$sql = array();
$s = "ALTER TABLE $tabname DROP(";
$s .= implode(', ',$flds).') CASCADE CONSTRAINTS';
$sql[] = $s;
return $sql;
}
function _DropAutoIncrement($t)
{
if (strpos($t,'.') !== false) {
$tarr = explode('.',$t);
return "drop sequence ".$tarr[0].".seq_".$tarr[1];
}
return "drop sequence seq_".$t;
}
// return string must begin with space
function _CreateSuffix($fname,&$ftype,$fnotnull,$fdefault,$fautoinc,$fconstraint,$funsigned)
{
$suffix = '';
if ($fdefault == "''" && $fnotnull) {// this is null in oracle
$fnotnull = false;
if ($this->debug) ADOConnection::outp("NOT NULL and DEFAULT='' illegal in Oracle");
}
if (strlen($fdefault)) $suffix .= " DEFAULT $fdefault";
if ($fnotnull) $suffix .= ' NOT NULL';
if ($fautoinc) $this->seqField = $fname;
if ($fconstraint) $suffix .= ' '.$fconstraint;
return $suffix;
}
/*
CREATE or replace TRIGGER jaddress_insert
before insert on jaddress
for each row
begin
select seqaddress.nextval into :new.A_ID from dual;
end;
*/
function _Triggers($tabname,$tableoptions)
{
if (!$this->seqField) return array();
if ($this->schema) {
$t = strpos($tabname,'.');
if ($t !== false) $tab = substr($tabname,$t+1);
else $tab = $tabname;
$seqname = $this->schema.'.'.$this->seqPrefix.$tab;
$trigname = $this->schema.'.'.$this->trigPrefix.$this->seqPrefix.$tab;
} else {
$seqname = $this->seqPrefix.$tabname;
$trigname = $this->trigPrefix.$seqname;
}
if (strlen($seqname) > 30) {
$seqname = $this->seqPrefix.uniqid('');
} // end if
if (strlen($trigname) > 30) {
$trigname = $this->trigPrefix.uniqid('');
} // end if
if (isset($tableoptions['REPLACE'])) $sql[] = "DROP SEQUENCE $seqname";
$seqCache = '';
if (isset($tableoptions['SEQUENCE_CACHE'])){$seqCache = $tableoptions['SEQUENCE_CACHE'];}
$seqIncr = '';
if (isset($tableoptions['SEQUENCE_INCREMENT'])){$seqIncr = ' INCREMENT BY '.$tableoptions['SEQUENCE_INCREMENT'];}
$seqStart = '';
if (isset($tableoptions['SEQUENCE_START'])){$seqIncr = ' START WITH '.$tableoptions['SEQUENCE_START'];}
$sql[] = "CREATE SEQUENCE $seqname $seqStart $seqIncr $seqCache";
$sql[] = "CREATE OR REPLACE TRIGGER $trigname BEFORE insert ON $tabname FOR EACH ROW WHEN (NEW.$this->seqField IS NULL OR NEW.$this->seqField = 0) BEGIN select $seqname.nextval into :new.$this->seqField from dual; END;";
$this->seqField = false;
return $sql;
}
/*
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name [(create_definition,...)]
[table_options] [select_statement]
create_definition:
col_name type [NOT NULL | NULL] [DEFAULT default_value] [AUTO_INCREMENT]
[PRIMARY KEY] [reference_definition]
or PRIMARY KEY (index_col_name,...)
or KEY [index_name] (index_col_name,...)
or INDEX [index_name] (index_col_name,...)
or UNIQUE [INDEX] [index_name] (index_col_name,...)
or FULLTEXT [INDEX] [index_name] (index_col_name,...)
or [CONSTRAINT symbol] FOREIGN KEY [index_name] (index_col_name,...)
[reference_definition]
or CHECK (expr)
*/
function _IndexSQL($idxname, $tabname, $flds,$idxoptions)
{
$sql = array();
if ( isset($idxoptions['REPLACE']) || isset($idxoptions['DROP']) ) {
$sql[] = sprintf ($this->dropIndex, $idxname, $tabname);
if ( isset($idxoptions['DROP']) )
return $sql;
}
if ( empty ($flds) ) {
return $sql;
}
if (isset($idxoptions['BITMAP'])) {
$unique = ' BITMAP';
} elseif (isset($idxoptions['UNIQUE'])) {
$unique = ' UNIQUE';
} else {
$unique = '';
}
if ( is_array($flds) )
$flds = implode(', ',$flds);
$s = 'CREATE' . $unique . ' INDEX ' . $idxname . ' ON ' . $tabname . ' (' . $flds . ')';
if ( isset($idxoptions[$this->upperName]) )
$s .= $idxoptions[$this->upperName];
if (isset($idxoptions['oci8']))
$s .= $idxoptions['oci8'];
$sql[] = $s;
return $sql;
}
function GetCommentSQL($table,$col)
{
$table = $this->connection->qstr($table);
$col = $this->connection->qstr($col);
return "select comments from USER_COL_COMMENTS where TABLE_NAME=$table and COLUMN_NAME=$col";
}
function SetCommentSQL($table,$col,$cmt)
{
$cmt = $this->connection->qstr($cmt);
return "COMMENT ON COLUMN $table.$col IS $cmt";
}
}
PK PW@{ { contrib/toxmlrpc.inc.phpnu W+A GetArray()) would work with:
* - ADODB_FETCH_BOTH
* - null values
*/
/**
* Include the main libraries
*/
require_once('xmlrpc.inc');
if (!defined('ADODB_DIR')) require_once('adodb.inc.php');
/**
* Builds an xmlrpc struct value out of an AdoDB recordset
*/
function rs2xmlrpcval(&$adodbrs) {
$header = rs2xmlrpcval_header($adodbrs);
$body = rs2xmlrpcval_body($adodbrs);
// put it all together and build final xmlrpc struct
$xmlrpcrs = new xmlrpcval ( array(
"header" => $header,
"body" => $body,
), "struct");
return $xmlrpcrs;
}
/**
* Builds an xmlrpc struct value describing an AdoDB recordset
*/
function rs2xmlrpcval_header($adodbrs)
{
$numfields = $adodbrs->FieldCount();
$numrecords = $adodbrs->RecordCount();
// build structure holding recordset information
$fieldstruct = array();
for ($i = 0; $i < $numfields; $i++) {
$fld = $adodbrs->FetchField($i);
$fieldarray = array();
if (isset($fld->name))
$fieldarray["name"] = new xmlrpcval ($fld->name);
if (isset($fld->type))
$fieldarray["type"] = new xmlrpcval ($fld->type);
if (isset($fld->max_length))
$fieldarray["max_length"] = new xmlrpcval ($fld->max_length, "int");
if (isset($fld->not_null))
$fieldarray["not_null"] = new xmlrpcval ($fld->not_null, "boolean");
if (isset($fld->has_default))
$fieldarray["has_default"] = new xmlrpcval ($fld->has_default, "boolean");
if (isset($fld->default_value))
$fieldarray["default_value"] = new xmlrpcval ($fld->default_value);
$fieldstruct[$i] = new xmlrpcval ($fieldarray, "struct");
}
$fieldcount = new xmlrpcval ($numfields, "int");
$recordcount = new xmlrpcval ($numrecords, "int");
$sql = new xmlrpcval ($adodbrs->sql);
$fieldinfo = new xmlrpcval ($fieldstruct, "array");
$header = new xmlrpcval ( array(
"fieldcount" => $fieldcount,
"recordcount" => $recordcount,
"sql" => $sql,
"fieldinfo" => $fieldinfo
), "struct");
return $header;
}
/**
* Builds an xmlrpc struct value out of an AdoDB recordset
* (data values only, no data definition)
*/
function rs2xmlrpcval_body($adodbrs)
{
$numfields = $adodbrs->FieldCount();
// build structure containing recordset data
$adodbrs->MoveFirst();
$rows = array();
while (!$adodbrs->EOF) {
$columns = array();
// This should work on all cases of fetch mode: assoc, num, both or default
if ($adodbrs->fetchMode == 'ADODB_FETCH_BOTH' || count($adodbrs->fields) == 2 * $adodbrs->FieldCount())
for ($i = 0; $i < $numfields; $i++)
if ($adodbrs->fields[$i] === null)
$columns[$i] = new xmlrpcval ('');
else
$columns[$i] = xmlrpc_encode ($adodbrs->fields[$i]);
else
foreach ($adodbrs->fields as $val)
if ($val === null)
$columns[] = new xmlrpcval ('');
else
$columns[] = xmlrpc_encode ($val);
$rows[] = new xmlrpcval ($columns, "array");
$adodbrs->MoveNext();
}
$body = new xmlrpcval ($rows, "array");
return $body;
}
/**
* Returns an xmlrpc struct value as string out of an AdoDB recordset
*/
function rs2xmlrpcstring (&$adodbrs) {
$xmlrpc = rs2xmlrpcval ($adodbrs);
if ($xmlrpc)
return $xmlrpc->serialize();
else
return null;
}
/**
* Given a well-formed xmlrpc struct object returns an AdoDB object
*
* @todo add some error checking on the input value
*/
function xmlrpcval2rs (&$xmlrpcval) {
$fields_array = array();
$data_array = array();
// rebuild column information
$header = $xmlrpcval->structmem('header');
$numfields = $header->structmem('fieldcount');
$numfields = $numfields->scalarval();
$numrecords = $header->structmem('recordcount');
$numrecords = $numrecords->scalarval();
$sqlstring = $header->structmem('sql');
$sqlstring = $sqlstring->scalarval();
$fieldinfo = $header->structmem('fieldinfo');
for ($i = 0; $i < $numfields; $i++) {
$temp = $fieldinfo->arraymem($i);
$fld = new ADOFieldObject();
while (list($key,$value) = $temp->structeach()) {
if ($key == "name") $fld->name = $value->scalarval();
if ($key == "type") $fld->type = $value->scalarval();
if ($key == "max_length") $fld->max_length = $value->scalarval();
if ($key == "not_null") $fld->not_null = $value->scalarval();
if ($key == "has_default") $fld->has_default = $value->scalarval();
if ($key == "default_value") $fld->default_value = $value->scalarval();
} // while
$fields_array[] = $fld;
} // for
// fetch recordset information into php array
$body = $xmlrpcval->structmem('body');
for ($i = 0; $i < $numrecords; $i++) {
$data_array[$i]= array();
$xmlrpcrs_row = $body->arraymem($i);
for ($j = 0; $j < $numfields; $j++) {
$temp = $xmlrpcrs_row->arraymem($j);
$data_array[$i][$j] = $temp->scalarval();
} // for j
} // for i
// finally build in-memory recordset object and return it
$rs = new ADORecordSet_array();
$rs->InitArrayFields($data_array,$fields_array);
return $rs;
}
PK PeJ adodb-xmlschema03.inc.phpnu W+A parent = $parent;
}
/**
* XML Callback to process start elements
*
* @access private
*/
function _tag_open( &$parser, $tag, $attributes ) {
}
/**
* XML Callback to process CDATA elements
*
* @access private
*/
function _tag_cdata( &$parser, $cdata ) {
}
/**
* XML Callback to process end elements
*
* @access private
*/
function _tag_close( &$parser, $tag ) {
}
function create(&$xmls) {
return array();
}
/**
* Destroys the object
*/
function destroy() {
}
/**
* Checks whether the specified RDBMS is supported by the current
* database object or its ranking ancestor.
*
* @param string $platform RDBMS platform name (from ADODB platform list).
* @return boolean TRUE if RDBMS is supported; otherwise returns FALSE.
*/
function supportedPlatform( $platform = NULL ) {
return is_object( $this->parent ) ? $this->parent->supportedPlatform( $platform ) : TRUE;
}
/**
* Returns the prefix set by the ranking ancestor of the database object.
*
* @param string $name Prefix string.
* @return string Prefix.
*/
function prefix( $name = '' ) {
return is_object( $this->parent ) ? $this->parent->prefix( $name ) : $name;
}
/**
* Extracts a field ID from the specified field.
*
* @param string $field Field.
* @return string Field ID.
*/
function FieldID( $field ) {
return strtoupper( preg_replace( '/^`(.+)`$/', '$1', $field ) );
}
}
/**
* Creates a table object in ADOdb's datadict format
*
* This class stores information about a database table. As charactaristics
* of the table are loaded from the external source, methods and properties
* of this class are used to build up the table description in ADOdb's
* datadict format.
*
* @package axmls
* @access private
*/
class dbTable extends dbObject {
/**
* @var string Table name
*/
var $name;
/**
* @var array Field specifier: Meta-information about each field
*/
var $fields = array();
/**
* @var array List of table indexes.
*/
var $indexes = array();
/**
* @var array Table options: Table-level options
*/
var $opts = array();
/**
* @var string Field index: Keeps track of which field is currently being processed
*/
var $current_field;
/**
* @var boolean Mark table for destruction
* @access private
*/
var $drop_table;
/**
* @var boolean Mark field for destruction (not yet implemented)
* @access private
*/
var $drop_field = array();
/**
* @var array Platform-specific options
* @access private
*/
var $currentPlatform = true;
/**
* Iniitializes a new table object.
*
* @param string $prefix DB Object prefix
* @param array $attributes Array of table attributes.
*/
function __construct( &$parent, $attributes = NULL ) {
$this->parent = $parent;
$this->name = $this->prefix($attributes['NAME']);
}
/**
* XML Callback to process start elements. Elements currently
* processed are: INDEX, DROP, FIELD, KEY, NOTNULL, AUTOINCREMENT & DEFAULT.
*
* @access private
*/
function _tag_open( &$parser, $tag, $attributes ) {
$this->currentElement = strtoupper( $tag );
switch( $this->currentElement ) {
case 'INDEX':
if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
$index = $this->addIndex( $attributes );
xml_set_object( $parser, $index );
}
break;
case 'DATA':
if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
$data = $this->addData( $attributes );
xml_set_object( $parser, $data );
}
break;
case 'DROP':
$this->drop();
break;
case 'FIELD':
// Add a field
$fieldName = $attributes['NAME'];
$fieldType = $attributes['TYPE'];
$fieldSize = isset( $attributes['SIZE'] ) ? $attributes['SIZE'] : NULL;
$fieldOpts = !empty( $attributes['OPTS'] ) ? $attributes['OPTS'] : NULL;
$this->addField( $fieldName, $fieldType, $fieldSize, $fieldOpts );
break;
case 'KEY':
case 'NOTNULL':
case 'AUTOINCREMENT':
case 'DEFDATE':
case 'DEFTIMESTAMP':
case 'UNSIGNED':
// Add a field option
$this->addFieldOpt( $this->current_field, $this->currentElement );
break;
case 'DEFAULT':
// Add a field option to the table object
// Work around ADOdb datadict issue that misinterprets empty strings.
if( $attributes['VALUE'] == '' ) {
$attributes['VALUE'] = " '' ";
}
$this->addFieldOpt( $this->current_field, $this->currentElement, $attributes['VALUE'] );
break;
case 'OPT':
case 'CONSTRAINT':
// Accept platform-specific options
$this->currentPlatform = ( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) );
break;
default:
// print_r( array( $tag, $attributes ) );
}
}
/**
* XML Callback to process CDATA elements
*
* @access private
*/
function _tag_cdata( &$parser, $cdata ) {
switch( $this->currentElement ) {
// Table/field constraint
case 'CONSTRAINT':
if( isset( $this->current_field ) ) {
$this->addFieldOpt( $this->current_field, $this->currentElement, $cdata );
} else {
$this->addTableOpt( $cdata );
}
break;
// Table/field option
case 'OPT':
if( isset( $this->current_field ) ) {
$this->addFieldOpt( $this->current_field, $cdata );
} else {
$this->addTableOpt( $cdata );
}
break;
default:
}
}
/**
* XML Callback to process end elements
*
* @access private
*/
function _tag_close( &$parser, $tag ) {
$this->currentElement = '';
switch( strtoupper( $tag ) ) {
case 'TABLE':
$this->parent->addSQL( $this->create( $this->parent ) );
xml_set_object( $parser, $this->parent );
$this->destroy();
break;
case 'FIELD':
unset($this->current_field);
break;
case 'OPT':
case 'CONSTRAINT':
$this->currentPlatform = true;
break;
default:
}
}
/**
* Adds an index to a table object
*
* @param array $attributes Index attributes
* @return object dbIndex object
*/
function addIndex( $attributes ) {
$name = strtoupper( $attributes['NAME'] );
$this->indexes[$name] = new dbIndex( $this, $attributes );
return $this->indexes[$name];
}
/**
* Adds data to a table object
*
* @param array $attributes Data attributes
* @return object dbData object
*/
function addData( $attributes ) {
if( !isset( $this->data ) ) {
$this->data = new dbData( $this, $attributes );
}
return $this->data;
}
/**
* Adds a field to a table object
*
* $name is the name of the table to which the field should be added.
* $type is an ADODB datadict field type. The following field types
* are supported as of ADODB 3.40:
* - C: varchar
* - X: CLOB (character large object) or largest varchar size
* if CLOB is not supported
* - C2: Multibyte varchar
* - X2: Multibyte CLOB
* - B: BLOB (binary large object)
* - D: Date (some databases do not support this, and we return a datetime type)
* - T: Datetime or Timestamp
* - L: Integer field suitable for storing booleans (0 or 1)
* - I: Integer (mapped to I4)
* - I1: 1-byte integer
* - I2: 2-byte integer
* - I4: 4-byte integer
* - I8: 8-byte integer
* - F: Floating point number
* - N: Numeric or decimal number
*
* @param string $name Name of the table to which the field will be added.
* @param string $type ADODB datadict field type.
* @param string $size Field size
* @param array $opts Field options array
* @return array Field specifier array
*/
function addField( $name, $type, $size = NULL, $opts = NULL ) {
$field_id = $this->FieldID( $name );
// Set the field index so we know where we are
$this->current_field = $field_id;
// Set the field name (required)
$this->fields[$field_id]['NAME'] = $name;
// Set the field type (required)
$this->fields[$field_id]['TYPE'] = $type;
// Set the field size (optional)
if( isset( $size ) ) {
$this->fields[$field_id]['SIZE'] = $size;
}
// Set the field options
if( isset( $opts ) ) {
$this->fields[$field_id]['OPTS'] = array($opts);
} else {
$this->fields[$field_id]['OPTS'] = array();
}
}
/**
* Adds a field option to the current field specifier
*
* This method adds a field option allowed by the ADOdb datadict
* and appends it to the given field.
*
* @param string $field Field name
* @param string $opt ADOdb field option
* @param mixed $value Field option value
* @return array Field specifier array
*/
function addFieldOpt( $field, $opt, $value = NULL ) {
if( $this->currentPlatform ) {
if( !isset( $value ) ) {
$this->fields[$this->FieldID( $field )]['OPTS'][] = $opt;
// Add the option and value
} else {
$this->fields[$this->FieldID( $field )]['OPTS'][] = array( $opt => $value );
}
}
}
/**
* Adds an option to the table
*
* This method takes a comma-separated list of table-level options
* and appends them to the table object.
*
* @param string $opt Table option
* @return array Options
*/
function addTableOpt( $opt ) {
if(isset($this->currentPlatform)) {
$this->opts[$this->parent->db->databaseType] = $opt;
}
return $this->opts;
}
/**
* Generates the SQL that will create the table in the database
*
* @param object $xmls adoSchema object
* @return array Array containing table creation SQL
*/
function create( &$xmls ) {
$sql = array();
// drop any existing indexes
if( is_array( $legacy_indexes = $xmls->dict->MetaIndexes( $this->name ) ) ) {
foreach( $legacy_indexes as $index => $index_details ) {
$sql[] = $xmls->dict->DropIndexSQL( $index, $this->name );
}
}
// remove fields to be dropped from table object
foreach( $this->drop_field as $field ) {
unset( $this->fields[$field] );
}
// if table exists
if( is_array( $legacy_fields = $xmls->dict->MetaColumns( $this->name ) ) ) {
// drop table
if( $this->drop_table ) {
$sql[] = $xmls->dict->DropTableSQL( $this->name );
return $sql;
}
// drop any existing fields not in schema
foreach( $legacy_fields as $field_id => $field ) {
if( !isset( $this->fields[$field_id] ) ) {
$sql[] = $xmls->dict->DropColumnSQL( $this->name, $field->name );
}
}
// if table doesn't exist
} else {
if( $this->drop_table ) {
return $sql;
}
$legacy_fields = array();
}
// Loop through the field specifier array, building the associative array for the field options
$fldarray = array();
foreach( $this->fields as $field_id => $finfo ) {
// Set an empty size if it isn't supplied
if( !isset( $finfo['SIZE'] ) ) {
$finfo['SIZE'] = '';
}
// Initialize the field array with the type and size
$fldarray[$field_id] = array(
'NAME' => $finfo['NAME'],
'TYPE' => $finfo['TYPE'],
'SIZE' => $finfo['SIZE']
);
// Loop through the options array and add the field options.
if( isset( $finfo['OPTS'] ) ) {
foreach( $finfo['OPTS'] as $opt ) {
// Option has an argument.
if( is_array( $opt ) ) {
$key = key( $opt );
$value = $opt[key( $opt )];
@$fldarray[$field_id][$key] .= $value;
// Option doesn't have arguments
} else {
$fldarray[$field_id][$opt] = $opt;
}
}
}
}
if( empty( $legacy_fields ) ) {
// Create the new table
$sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
logMsg( end( $sql ), 'Generated CreateTableSQL' );
} else {
// Upgrade an existing table
logMsg( "Upgrading {$this->name} using '{$xmls->upgrade}'" );
switch( $xmls->upgrade ) {
// Use ChangeTableSQL
case 'ALTER':
logMsg( 'Generated ChangeTableSQL (ALTERing table)' );
$sql[] = $xmls->dict->ChangeTableSQL( $this->name, $fldarray, $this->opts );
break;
case 'REPLACE':
logMsg( 'Doing upgrade REPLACE (testing)' );
$sql[] = $xmls->dict->DropTableSQL( $this->name );
$sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
break;
// ignore table
default:
return array();
}
}
foreach( $this->indexes as $index ) {
$sql[] = $index->create( $xmls );
}
if( isset( $this->data ) ) {
$sql[] = $this->data->create( $xmls );
}
return $sql;
}
/**
* Marks a field or table for destruction
*/
function drop() {
if( isset( $this->current_field ) ) {
// Drop the current field
logMsg( "Dropping field '{$this->current_field}' from table '{$this->name}'" );
// $this->drop_field[$this->current_field] = $xmls->dict->DropColumnSQL( $this->name, $this->current_field );
$this->drop_field[$this->current_field] = $this->current_field;
} else {
// Drop the current table
logMsg( "Dropping table '{$this->name}'" );
// $this->drop_table = $xmls->dict->DropTableSQL( $this->name );
$this->drop_table = TRUE;
}
}
}
/**
* Creates an index object in ADOdb's datadict format
*
* This class stores information about a database index. As charactaristics
* of the index are loaded from the external source, methods and properties
* of this class are used to build up the index description in ADOdb's
* datadict format.
*
* @package axmls
* @access private
*/
class dbIndex extends dbObject {
/**
* @var string Index name
*/
var $name;
/**
* @var array Index options: Index-level options
*/
var $opts = array();
/**
* @var array Indexed fields: Table columns included in this index
*/
var $columns = array();
/**
* @var boolean Mark index for destruction
* @access private
*/
var $drop = FALSE;
/**
* Initializes the new dbIndex object.
*
* @param object $parent Parent object
* @param array $attributes Attributes
*
* @internal
*/
function __construct( &$parent, $attributes = NULL ) {
$this->parent = $parent;
$this->name = $this->prefix ($attributes['NAME']);
}
/**
* XML Callback to process start elements
*
* Processes XML opening tags.
* Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH.
*
* @access private
*/
function _tag_open( &$parser, $tag, $attributes ) {
$this->currentElement = strtoupper( $tag );
switch( $this->currentElement ) {
case 'DROP':
$this->drop();
break;
case 'CLUSTERED':
case 'BITMAP':
case 'UNIQUE':
case 'FULLTEXT':
case 'HASH':
// Add index Option
$this->addIndexOpt( $this->currentElement );
break;
default:
// print_r( array( $tag, $attributes ) );
}
}
/**
* XML Callback to process CDATA elements
*
* Processes XML cdata.
*
* @access private
*/
function _tag_cdata( &$parser, $cdata ) {
switch( $this->currentElement ) {
// Index field name
case 'COL':
$this->addField( $cdata );
break;
default:
}
}
/**
* XML Callback to process end elements
*
* @access private
*/
function _tag_close( &$parser, $tag ) {
$this->currentElement = '';
switch( strtoupper( $tag ) ) {
case 'INDEX':
xml_set_object( $parser, $this->parent );
break;
}
}
/**
* Adds a field to the index
*
* @param string $name Field name
* @return string Field list
*/
function addField( $name ) {
$this->columns[$this->FieldID( $name )] = $name;
// Return the field list
return $this->columns;
}
/**
* Adds options to the index
*
* @param string $opt Comma-separated list of index options.
* @return string Option list
*/
function addIndexOpt( $opt ) {
$this->opts[] = $opt;
// Return the options list
return $this->opts;
}
/**
* Generates the SQL that will create the index in the database
*
* @param object $xmls adoSchema object
* @return array Array containing index creation SQL
*/
function create( &$xmls ) {
if( $this->drop ) {
return NULL;
}
// eliminate any columns that aren't in the table
foreach( $this->columns as $id => $col ) {
if( !isset( $this->parent->fields[$id] ) ) {
unset( $this->columns[$id] );
}
}
return $xmls->dict->CreateIndexSQL( $this->name, $this->parent->name, $this->columns, $this->opts );
}
/**
* Marks an index for destruction
*/
function drop() {
$this->drop = TRUE;
}
}
/**
* Creates a data object in ADOdb's datadict format
*
* This class stores information about table data, and is called
* when we need to load field data into a table.
*
* @package axmls
* @access private
*/
class dbData extends dbObject {
var $data = array();
var $row;
/**
* Initializes the new dbData object.
*
* @param object $parent Parent object
* @param array $attributes Attributes
*
* @internal
*/
function __construct( &$parent, $attributes = NULL ) {
$this->parent = $parent;
}
/**
* XML Callback to process start elements
*
* Processes XML opening tags.
* Elements currently processed are: ROW and F (field).
*
* @access private
*/
function _tag_open( &$parser, $tag, $attributes ) {
$this->currentElement = strtoupper( $tag );
switch( $this->currentElement ) {
case 'ROW':
$this->row = count( $this->data );
$this->data[$this->row] = array();
break;
case 'F':
$this->addField($attributes);
default:
// print_r( array( $tag, $attributes ) );
}
}
/**
* XML Callback to process CDATA elements
*
* Processes XML cdata.
*
* @access private
*/
function _tag_cdata( &$parser, $cdata ) {
switch( $this->currentElement ) {
// Index field name
case 'F':
$this->addData( $cdata );
break;
default:
}
}
/**
* XML Callback to process end elements
*
* @access private
*/
function _tag_close( &$parser, $tag ) {
$this->currentElement = '';
switch( strtoupper( $tag ) ) {
case 'DATA':
xml_set_object( $parser, $this->parent );
break;
}
}
/**
* Adds a field to the insert
*
* @param string $name Field name
* @return string Field list
*/
function addField( $attributes ) {
// check we're in a valid row
if( !isset( $this->row ) || !isset( $this->data[$this->row] ) ) {
return;
}
// Set the field index so we know where we are
if( isset( $attributes['NAME'] ) ) {
$this->current_field = $this->FieldID( $attributes['NAME'] );
} else {
$this->current_field = count( $this->data[$this->row] );
}
// initialise data
if( !isset( $this->data[$this->row][$this->current_field] ) ) {
$this->data[$this->row][$this->current_field] = '';
}
}
/**
* Adds options to the index
*
* @param string $opt Comma-separated list of index options.
* @return string Option list
*/
function addData( $cdata ) {
// check we're in a valid field
if ( isset( $this->data[$this->row][$this->current_field] ) ) {
// add data to field
$this->data[$this->row][$this->current_field] .= $cdata;
}
}
/**
* Generates the SQL that will add/update the data in the database
*
* @param object $xmls adoSchema object
* @return array Array containing index creation SQL
*/
function create( &$xmls ) {
$table = $xmls->dict->TableName($this->parent->name);
$table_field_count = count($this->parent->fields);
$tables = $xmls->db->MetaTables();
$sql = array();
$ukeys = $xmls->db->MetaPrimaryKeys( $table );
if( !empty( $this->parent->indexes ) and !empty( $ukeys ) ) {
foreach( $this->parent->indexes as $indexObj ) {
if( !in_array( $indexObj->name, $ukeys ) ) $ukeys[] = $indexObj->name;
}
}
// eliminate any columns that aren't in the table
foreach( $this->data as $row ) {
$table_fields = $this->parent->fields;
$fields = array();
$rawfields = array(); // Need to keep some of the unprocessed data on hand.
foreach( $row as $field_id => $field_data ) {
if( !array_key_exists( $field_id, $table_fields ) ) {
if( is_numeric( $field_id ) ) {
$field_id = reset( array_keys( $table_fields ) );
} else {
continue;
}
}
$name = $table_fields[$field_id]['NAME'];
switch( $table_fields[$field_id]['TYPE'] ) {
case 'I':
case 'I1':
case 'I2':
case 'I4':
case 'I8':
$fields[$name] = intval($field_data);
break;
case 'C':
case 'C2':
case 'X':
case 'X2':
default:
$fields[$name] = $xmls->db->qstr( $field_data );
$rawfields[$name] = $field_data;
}
unset($table_fields[$field_id]);
}
// check that at least 1 column is specified
if( empty( $fields ) ) {
continue;
}
// check that no required columns are missing
if( count( $fields ) < $table_field_count ) {
foreach( $table_fields as $field ) {
if( isset( $field['OPTS'] ) and ( in_array( 'NOTNULL', $field['OPTS'] ) || in_array( 'KEY', $field['OPTS'] ) ) && !in_array( 'AUTOINCREMENT', $field['OPTS'] ) ) {
continue(2);
}
}
}
// The rest of this method deals with updating existing data records.
if( !in_array( $table, $tables ) or ( $mode = $xmls->existingData() ) == XMLS_MODE_INSERT ) {
// Table doesn't yet exist, so it's safe to insert.
logMsg( "$table doesn't exist, inserting or mode is INSERT" );
$sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
continue;
}
// Prepare to test for potential violations. Get primary keys and unique indexes
$mfields = array_merge( $fields, $rawfields );
$keyFields = array_intersect( $ukeys, array_keys( $mfields ) );
if( empty( $ukeys ) or count( $keyFields ) == 0 ) {
// No unique keys in schema, so safe to insert
logMsg( "Either schema or data has no unique keys, so safe to insert" );
$sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
continue;
}
// Select record containing matching unique keys.
$where = '';
foreach( $ukeys as $key ) {
if( isset( $mfields[$key] ) and $mfields[$key] ) {
if( $where ) $where .= ' AND ';
$where .= $key . ' = ' . $xmls->db->qstr( $mfields[$key] );
}
}
$records = $xmls->db->Execute( 'SELECT * FROM ' . $table . ' WHERE ' . $where );
switch( $records->RecordCount() ) {
case 0:
// No matching record, so safe to insert.
logMsg( "No matching records. Inserting new row with unique data" );
$sql[] = $xmls->db->GetInsertSQL( $records, $mfields );
break;
case 1:
// Exactly one matching record, so we can update if the mode permits.
logMsg( "One matching record..." );
if( $mode == XMLS_MODE_UPDATE ) {
logMsg( "...Updating existing row from unique data" );
$sql[] = $xmls->db->GetUpdateSQL( $records, $mfields );
}
break;
default:
// More than one matching record; the result is ambiguous, so we must ignore the row.
logMsg( "More than one matching record. Ignoring row." );
}
}
return $sql;
}
}
/**
* Creates the SQL to execute a list of provided SQL queries
*
* @package axmls
* @access private
*/
class dbQuerySet extends dbObject {
/**
* @var array List of SQL queries
*/
var $queries = array();
/**
* @var string String used to build of a query line by line
*/
var $query;
/**
* @var string Query prefix key
*/
var $prefixKey = '';
/**
* @var boolean Auto prefix enable (TRUE)
*/
var $prefixMethod = 'AUTO';
/**
* Initializes the query set.
*
* @param object $parent Parent object
* @param array $attributes Attributes
*/
function __construct( &$parent, $attributes = NULL ) {
$this->parent = $parent;
// Overrides the manual prefix key
if( isset( $attributes['KEY'] ) ) {
$this->prefixKey = $attributes['KEY'];
}
$prefixMethod = isset( $attributes['PREFIXMETHOD'] ) ? strtoupper( trim( $attributes['PREFIXMETHOD'] ) ) : '';
// Enables or disables automatic prefix prepending
switch( $prefixMethod ) {
case 'AUTO':
$this->prefixMethod = 'AUTO';
break;
case 'MANUAL':
$this->prefixMethod = 'MANUAL';
break;
case 'NONE':
$this->prefixMethod = 'NONE';
break;
}
}
/**
* XML Callback to process start elements. Elements currently
* processed are: QUERY.
*
* @access private
*/
function _tag_open( &$parser, $tag, $attributes ) {
$this->currentElement = strtoupper( $tag );
switch( $this->currentElement ) {
case 'QUERY':
// Create a new query in a SQL queryset.
// Ignore this query set if a platform is specified and it's different than the
// current connection platform.
if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
$this->newQuery();
} else {
$this->discardQuery();
}
break;
default:
// print_r( array( $tag, $attributes ) );
}
}
/**
* XML Callback to process CDATA elements
*/
function _tag_cdata( &$parser, $cdata ) {
switch( $this->currentElement ) {
// Line of queryset SQL data
case 'QUERY':
$this->buildQuery( $cdata );
break;
default:
}
}
/**
* XML Callback to process end elements
*
* @access private
*/
function _tag_close( &$parser, $tag ) {
$this->currentElement = '';
switch( strtoupper( $tag ) ) {
case 'QUERY':
// Add the finished query to the open query set.
$this->addQuery();
break;
case 'SQL':
$this->parent->addSQL( $this->create( $this->parent ) );
xml_set_object( $parser, $this->parent );
$this->destroy();
break;
default:
}
}
/**
* Re-initializes the query.
*
* @return boolean TRUE
*/
function newQuery() {
$this->query = '';
return TRUE;
}
/**
* Discards the existing query.
*
* @return boolean TRUE
*/
function discardQuery() {
unset( $this->query );
return TRUE;
}
/**
* Appends a line to a query that is being built line by line
*
* @param string $data Line of SQL data or NULL to initialize a new query
* @return string SQL query string.
*/
function buildQuery( $sql = NULL ) {
if( !isset( $this->query ) OR empty( $sql ) ) {
return FALSE;
}
$this->query .= $sql;
return $this->query;
}
/**
* Adds a completed query to the query list
*
* @return string SQL of added query
*/
function addQuery() {
if( !isset( $this->query ) ) {
return FALSE;
}
$this->queries[] = $return = trim($this->query);
unset( $this->query );
return $return;
}
/**
* Creates and returns the current query set
*
* @param object $xmls adoSchema object
* @return array Query set
*/
function create( &$xmls ) {
foreach( $this->queries as $id => $query ) {
switch( $this->prefixMethod ) {
case 'AUTO':
// Enable auto prefix replacement
// Process object prefix.
// Evaluate SQL statements to prepend prefix to objects
$query = $this->prefixQuery( '/^\s*((?is)INSERT\s+(INTO\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
$query = $this->prefixQuery( '/^\s*((?is)UPDATE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
$query = $this->prefixQuery( '/^\s*((?is)DELETE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
// SELECT statements aren't working yet
#$data = preg_replace( '/(?ias)(^\s*SELECT\s+.*\s+FROM)\s+(\W\s*,?\s*)+((?i)\s+WHERE.*$)/', "\1 $prefix\2 \3", $data );
case 'MANUAL':
// If prefixKey is set and has a value then we use it to override the default constant XMLS_PREFIX.
// If prefixKey is not set, we use the default constant XMLS_PREFIX
if( isset( $this->prefixKey ) AND( $this->prefixKey !== '' ) ) {
// Enable prefix override
$query = str_replace( $this->prefixKey, $xmls->objectPrefix, $query );
} else {
// Use default replacement
$query = str_replace( XMLS_PREFIX , $xmls->objectPrefix, $query );
}
}
$this->queries[$id] = trim( $query );
}
// Return the query set array
return $this->queries;
}
/**
* Rebuilds the query with the prefix attached to any objects
*
* @param string $regex Regex used to add prefix
* @param string $query SQL query string
* @param string $prefix Prefix to be appended to tables, indices, etc.
* @return string Prefixed SQL query string.
*/
function prefixQuery( $regex, $query, $prefix = NULL ) {
if( !isset( $prefix ) ) {
return $query;
}
if( preg_match( $regex, $query, $match ) ) {
$preamble = $match[1];
$postamble = $match[5];
$objectList = explode( ',', $match[3] );
// $prefix = $prefix . '_';
$prefixedList = '';
foreach( $objectList as $object ) {
if( $prefixedList !== '' ) {
$prefixedList .= ', ';
}
$prefixedList .= $prefix . trim( $object );
}
$query = $preamble . ' ' . $prefixedList . ' ' . $postamble;
}
return $query;
}
}
/**
* Loads and parses an XML file, creating an array of "ready-to-run" SQL statements
*
* This class is used to load and parse the XML file, to create an array of SQL statements
* that can be used to build a database, and to build the database using the SQL array.
*
* @tutorial getting_started.pkg
*
* @author Richard Tango-Lowy & Dan Cech
* @version $Revision: 1.62 $
*
* @package axmls
*/
class adoSchema {
/**
* @var array Array containing SQL queries to generate all objects
* @access private
*/
var $sqlArray;
/**
* @var object ADOdb connection object
* @access private
*/
var $db;
/**
* @var object ADOdb Data Dictionary
* @access private
*/
var $dict;
/**
* @var string Current XML element
* @access private
*/
var $currentElement = '';
/**
* @var string If set (to 'ALTER' or 'REPLACE'), upgrade an existing database
* @access private
*/
var $upgrade = '';
/**
* @var string Optional object prefix
* @access private
*/
var $objectPrefix = '';
/**
* @var long Original Magic Quotes Runtime value
* @access private
*/
var $mgq;
/**
* @var long System debug
* @access private
*/
var $debug;
/**
* @var string Regular expression to find schema version
* @access private
*/
var $versionRegex = '//';
/**
* @var string Current schema version
* @access private
*/
var $schemaVersion;
/**
* @var int Success of last Schema execution
*/
var $success;
/**
* @var bool Execute SQL inline as it is generated
*/
var $executeInline;
/**
* @var bool Continue SQL execution if errors occur
*/
var $continueOnError;
/**
* @var int How to handle existing data rows (insert, update, or ignore)
*/
var $existingData;
/**
* Creates an adoSchema object
*
* Creating an adoSchema object is the first step in processing an XML schema.
* The only parameter is an ADOdb database connection object, which must already
* have been created.
*
* @param object $db ADOdb database connection object.
*/
function __construct( $db ) {
// Initialize the environment
$this->mgq = get_magic_quotes_runtime();
if ($this->mgq !== false) {
ini_set('magic_quotes_runtime', 0 );
}
$this->db = $db;
$this->debug = $this->db->debug;
$this->dict = NewDataDictionary( $this->db );
$this->sqlArray = array();
$this->schemaVersion = XMLS_SCHEMA_VERSION;
$this->executeInline( XMLS_EXECUTE_INLINE );
$this->continueOnError( XMLS_CONTINUE_ON_ERROR );
$this->existingData( XMLS_EXISTING_DATA );
$this->setUpgradeMethod();
}
/**
* Sets the method to be used for upgrading an existing database
*
* Use this method to specify how existing database objects should be upgraded.
* The method option can be set to ALTER, REPLACE, BEST, or NONE. ALTER attempts to
* alter each database object directly, REPLACE attempts to rebuild each object
* from scratch, BEST attempts to determine the best upgrade method for each
* object, and NONE disables upgrading.
*
* This method is not yet used by AXMLS, but exists for backward compatibility.
* The ALTER method is automatically assumed when the adoSchema object is
* instantiated; other upgrade methods are not currently supported.
*
* @param string $method Upgrade method (ALTER|REPLACE|BEST|NONE)
* @returns string Upgrade method used
*/
function SetUpgradeMethod( $method = '' ) {
if( !is_string( $method ) ) {
return FALSE;
}
$method = strtoupper( $method );
// Handle the upgrade methods
switch( $method ) {
case 'ALTER':
$this->upgrade = $method;
break;
case 'REPLACE':
$this->upgrade = $method;
break;
case 'BEST':
$this->upgrade = 'ALTER';
break;
case 'NONE':
$this->upgrade = 'NONE';
break;
default:
// Use default if no legitimate method is passed.
$this->upgrade = XMLS_DEFAULT_UPGRADE_METHOD;
}
return $this->upgrade;
}
/**
* Specifies how to handle existing data row when there is a unique key conflict.
*
* The existingData setting specifies how the parser should handle existing rows
* when a unique key violation occurs during the insert. This can happen when inserting
* data into an existing table with one or more primary keys or unique indexes.
* The existingData method takes one of three options: XMLS_MODE_INSERT attempts
* to always insert the data as a new row. In the event of a unique key violation,
* the database will generate an error. XMLS_MODE_UPDATE attempts to update the
* any existing rows with the new data based upon primary or unique key fields in
* the schema. If the data row in the schema specifies no unique fields, the row
* data will be inserted as a new row. XMLS_MODE_IGNORE specifies that any data rows
* that would result in a unique key violation be ignored; no inserts or updates will
* take place. For backward compatibility, the default setting is XMLS_MODE_INSERT,
* but XMLS_MODE_UPDATE will generally be the most appropriate setting.
*
* @param int $mode XMLS_MODE_INSERT, XMLS_MODE_UPDATE, or XMLS_MODE_IGNORE
* @return int current mode
*/
function ExistingData( $mode = NULL ) {
if( is_int( $mode ) ) {
switch( $mode ) {
case XMLS_MODE_UPDATE:
$mode = XMLS_MODE_UPDATE;
break;
case XMLS_MODE_IGNORE:
$mode = XMLS_MODE_IGNORE;
break;
case XMLS_MODE_INSERT:
$mode = XMLS_MODE_INSERT;
break;
default:
$mode = XMLS_EXISTING_DATA;
break;
}
$this->existingData = $mode;
}
return $this->existingData;
}
/**
* Enables/disables inline SQL execution.
*
* Call this method to enable or disable inline execution of the schema. If the mode is set to TRUE (inline execution),
* AXMLS applies the SQL to the database immediately as each schema entity is parsed. If the mode
* is set to FALSE (post execution), AXMLS parses the entire schema and you will need to call adoSchema::ExecuteSchema()
* to apply the schema to the database.
*
* @param bool $mode execute
* @return bool current execution mode
*
* @see ParseSchema(), ExecuteSchema()
*/
function ExecuteInline( $mode = NULL ) {
if( is_bool( $mode ) ) {
$this->executeInline = $mode;
}
return $this->executeInline;
}
/**
* Enables/disables SQL continue on error.
*
* Call this method to enable or disable continuation of SQL execution if an error occurs.
* If the mode is set to TRUE (continue), AXMLS will continue to apply SQL to the database, even if an error occurs.
* If the mode is set to FALSE (halt), AXMLS will halt execution of generated sql if an error occurs, though parsing
* of the schema will continue.
*
* @param bool $mode execute
* @return bool current continueOnError mode
*
* @see addSQL(), ExecuteSchema()
*/
function ContinueOnError( $mode = NULL ) {
if( is_bool( $mode ) ) {
$this->continueOnError = $mode;
}
return $this->continueOnError;
}
/**
* Loads an XML schema from a file and converts it to SQL.
*
* Call this method to load the specified schema (see the DTD for the proper format) from
* the filesystem and generate the SQL necessary to create the database
* described. This method automatically converts the schema to the latest
* axmls schema version.
* @see ParseSchemaString()
*
* @param string $file Name of XML schema file.
* @param bool $returnSchema Return schema rather than parsing.
* @return array Array of SQL queries, ready to execute
*/
function ParseSchema( $filename, $returnSchema = FALSE ) {
return $this->ParseSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
}
/**
* Loads an XML schema from a file and converts it to SQL.
*
* Call this method to load the specified schema directly from a file (see
* the DTD for the proper format) and generate the SQL necessary to create
* the database described by the schema. Use this method when you are dealing
* with large schema files. Otherwise, ParseSchema() is faster.
* This method does not automatically convert the schema to the latest axmls
* schema version. You must convert the schema manually using either the
* ConvertSchemaFile() or ConvertSchemaString() method.
* @see ParseSchema()
* @see ConvertSchemaFile()
* @see ConvertSchemaString()
*
* @param string $file Name of XML schema file.
* @param bool $returnSchema Return schema rather than parsing.
* @return array Array of SQL queries, ready to execute.
*
* @deprecated Replaced by adoSchema::ParseSchema() and adoSchema::ParseSchemaString()
* @see ParseSchema(), ParseSchemaString()
*/
function ParseSchemaFile( $filename, $returnSchema = FALSE ) {
// Open the file
if( !($fp = fopen( $filename, 'r' )) ) {
logMsg( 'Unable to open file' );
return FALSE;
}
// do version detection here
if( $this->SchemaFileVersion( $filename ) != $this->schemaVersion ) {
logMsg( 'Invalid Schema Version' );
return FALSE;
}
if( $returnSchema ) {
$xmlstring = '';
while( $data = fread( $fp, 4096 ) ) {
$xmlstring .= $data . "\n";
}
return $xmlstring;
}
$this->success = 2;
$xmlParser = $this->create_parser();
// Process the file
while( $data = fread( $fp, 4096 ) ) {
if( !xml_parse( $xmlParser, $data, feof( $fp ) ) ) {
die( sprintf(
"XML error: %s at line %d",
xml_error_string( xml_get_error_code( $xmlParser) ),
xml_get_current_line_number( $xmlParser)
) );
}
}
xml_parser_free( $xmlParser );
return $this->sqlArray;
}
/**
* Converts an XML schema string to SQL.
*
* Call this method to parse a string containing an XML schema (see the DTD for the proper format)
* and generate the SQL necessary to create the database described by the schema.
* @see ParseSchema()
*
* @param string $xmlstring XML schema string.
* @param bool $returnSchema Return schema rather than parsing.
* @return array Array of SQL queries, ready to execute.
*/
function ParseSchemaString( $xmlstring, $returnSchema = FALSE ) {
if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
logMsg( 'Empty or Invalid Schema' );
return FALSE;
}
// do version detection here
if( $this->SchemaStringVersion( $xmlstring ) != $this->schemaVersion ) {
logMsg( 'Invalid Schema Version' );
return FALSE;
}
if( $returnSchema ) {
return $xmlstring;
}
$this->success = 2;
$xmlParser = $this->create_parser();
if( !xml_parse( $xmlParser, $xmlstring, TRUE ) ) {
die( sprintf(
"XML error: %s at line %d",
xml_error_string( xml_get_error_code( $xmlParser) ),
xml_get_current_line_number( $xmlParser)
) );
}
xml_parser_free( $xmlParser );
return $this->sqlArray;
}
/**
* Loads an XML schema from a file and converts it to uninstallation SQL.
*
* Call this method to load the specified schema (see the DTD for the proper format) from
* the filesystem and generate the SQL necessary to remove the database described.
* @see RemoveSchemaString()
*
* @param string $file Name of XML schema file.
* @param bool $returnSchema Return schema rather than parsing.
* @return array Array of SQL queries, ready to execute
*/
function RemoveSchema( $filename, $returnSchema = FALSE ) {
return $this->RemoveSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
}
/**
* Converts an XML schema string to uninstallation SQL.
*
* Call this method to parse a string containing an XML schema (see the DTD for the proper format)
* and generate the SQL necessary to uninstall the database described by the schema.
* @see RemoveSchema()
*
* @param string $schema XML schema string.
* @param bool $returnSchema Return schema rather than parsing.
* @return array Array of SQL queries, ready to execute.
*/
function RemoveSchemaString( $schema, $returnSchema = FALSE ) {
// grab current version
if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
return FALSE;
}
return $this->ParseSchemaString( $this->TransformSchema( $schema, 'remove-' . $version), $returnSchema );
}
/**
* Applies the current XML schema to the database (post execution).
*
* Call this method to apply the current schema (generally created by calling
* ParseSchema() or ParseSchemaString() ) to the database (creating the tables, indexes,
* and executing other SQL specified in the schema) after parsing.
* @see ParseSchema(), ParseSchemaString(), ExecuteInline()
*
* @param array $sqlArray Array of SQL statements that will be applied rather than
* the current schema.
* @param boolean $continueOnErr Continue to apply the schema even if an error occurs.
* @returns integer 0 if failure, 1 if errors, 2 if successful.
*/
function ExecuteSchema( $sqlArray = NULL, $continueOnErr = NULL ) {
if( !is_bool( $continueOnErr ) ) {
$continueOnErr = $this->ContinueOnError();
}
if( !isset( $sqlArray ) ) {
$sqlArray = $this->sqlArray;
}
if( !is_array( $sqlArray ) ) {
$this->success = 0;
} else {
$this->success = $this->dict->ExecuteSQLArray( $sqlArray, $continueOnErr );
}
return $this->success;
}
/**
* Returns the current SQL array.
*
* Call this method to fetch the array of SQL queries resulting from
* ParseSchema() or ParseSchemaString().
*
* @param string $format Format: HTML, TEXT, or NONE (PHP array)
* @return array Array of SQL statements or FALSE if an error occurs
*/
function PrintSQL( $format = 'NONE' ) {
$sqlArray = null;
return $this->getSQL( $format, $sqlArray );
}
/**
* Saves the current SQL array to the local filesystem as a list of SQL queries.
*
* Call this method to save the array of SQL queries (generally resulting from a
* parsed XML schema) to the filesystem.
*
* @param string $filename Path and name where the file should be saved.
* @return boolean TRUE if save is successful, else FALSE.
*/
function SaveSQL( $filename = './schema.sql' ) {
if( !isset( $sqlArray ) ) {
$sqlArray = $this->sqlArray;
}
if( !isset( $sqlArray ) ) {
return FALSE;
}
$fp = fopen( $filename, "w" );
foreach( $sqlArray as $key => $query ) {
fwrite( $fp, $query . ";\n" );
}
fclose( $fp );
}
/**
* Create an xml parser
*
* @return object PHP XML parser object
*
* @access private
*/
function create_parser() {
// Create the parser
$xmlParser = xml_parser_create();
xml_set_object( $xmlParser, $this );
// Initialize the XML callback functions
xml_set_element_handler( $xmlParser, '_tag_open', '_tag_close' );
xml_set_character_data_handler( $xmlParser, '_tag_cdata' );
return $xmlParser;
}
/**
* XML Callback to process start elements
*
* @access private
*/
function _tag_open( &$parser, $tag, $attributes ) {
switch( strtoupper( $tag ) ) {
case 'TABLE':
if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
$this->obj = new dbTable( $this, $attributes );
xml_set_object( $parser, $this->obj );
}
break;
case 'SQL':
if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
$this->obj = new dbQuerySet( $this, $attributes );
xml_set_object( $parser, $this->obj );
}
break;
default:
// print_r( array( $tag, $attributes ) );
}
}
/**
* XML Callback to process CDATA elements
*
* @access private
*/
function _tag_cdata( &$parser, $cdata ) {
}
/**
* XML Callback to process end elements
*
* @access private
* @internal
*/
function _tag_close( &$parser, $tag ) {
}
/**
* Converts an XML schema string to the specified DTD version.
*
* Call this method to convert a string containing an XML schema to a different AXMLS
* DTD version. For instance, to convert a schema created for an pre-1.0 version for
* AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version
* parameter is specified, the schema will be converted to the current DTD version.
* If the newFile parameter is provided, the converted schema will be written to the specified
* file.
* @see ConvertSchemaFile()
*
* @param string $schema String containing XML schema that will be converted.
* @param string $newVersion DTD version to convert to.
* @param string $newFile File name of (converted) output file.
* @return string Converted XML schema or FALSE if an error occurs.
*/
function ConvertSchemaString( $schema, $newVersion = NULL, $newFile = NULL ) {
// grab current version
if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
return FALSE;
}
if( !isset ($newVersion) ) {
$newVersion = $this->schemaVersion;
}
if( $version == $newVersion ) {
$result = $schema;
} else {
$result = $this->TransformSchema( $schema, 'convert-' . $version . '-' . $newVersion);
}
if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
fwrite( $fp, $result );
fclose( $fp );
}
return $result;
}
/*
// compat for pre-4.3 - jlim
function _file_get_contents($path)
{
if (function_exists('file_get_contents')) return file_get_contents($path);
return join('',file($path));
}*/
/**
* Converts an XML schema file to the specified DTD version.
*
* Call this method to convert the specified XML schema file to a different AXMLS
* DTD version. For instance, to convert a schema created for an pre-1.0 version for
* AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version
* parameter is specified, the schema will be converted to the current DTD version.
* If the newFile parameter is provided, the converted schema will be written to the specified
* file.
* @see ConvertSchemaString()
*
* @param string $filename Name of XML schema file that will be converted.
* @param string $newVersion DTD version to convert to.
* @param string $newFile File name of (converted) output file.
* @return string Converted XML schema or FALSE if an error occurs.
*/
function ConvertSchemaFile( $filename, $newVersion = NULL, $newFile = NULL ) {
// grab current version
if( !( $version = $this->SchemaFileVersion( $filename ) ) ) {
return FALSE;
}
if( !isset ($newVersion) ) {
$newVersion = $this->schemaVersion;
}
if( $version == $newVersion ) {
$result = _file_get_contents( $filename );
// remove unicode BOM if present
if( substr( $result, 0, 3 ) == sprintf( '%c%c%c', 239, 187, 191 ) ) {
$result = substr( $result, 3 );
}
} else {
$result = $this->TransformSchema( $filename, 'convert-' . $version . '-' . $newVersion, 'file' );
}
if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
fwrite( $fp, $result );
fclose( $fp );
}
return $result;
}
function TransformSchema( $schema, $xsl, $schematype='string' )
{
// Fail if XSLT extension is not available
if( ! function_exists( 'xslt_create' ) ) {
return FALSE;
}
$xsl_file = dirname( __FILE__ ) . '/xsl/' . $xsl . '.xsl';
// look for xsl
if( !is_readable( $xsl_file ) ) {
return FALSE;
}
switch( $schematype )
{
case 'file':
if( !is_readable( $schema ) ) {
return FALSE;
}
$schema = _file_get_contents( $schema );
break;
case 'string':
default:
if( !is_string( $schema ) ) {
return FALSE;
}
}
$arguments = array (
'/_xml' => $schema,
'/_xsl' => _file_get_contents( $xsl_file )
);
// create an XSLT processor
$xh = xslt_create ();
// set error handler
xslt_set_error_handler ($xh, array (&$this, 'xslt_error_handler'));
// process the schema
$result = xslt_process ($xh, 'arg:/_xml', 'arg:/_xsl', NULL, $arguments);
xslt_free ($xh);
return $result;
}
/**
* Processes XSLT transformation errors
*
* @param object $parser XML parser object
* @param integer $errno Error number
* @param integer $level Error level
* @param array $fields Error information fields
*
* @access private
*/
function xslt_error_handler( $parser, $errno, $level, $fields ) {
if( is_array( $fields ) ) {
$msg = array(
'Message Type' => ucfirst( $fields['msgtype'] ),
'Message Code' => $fields['code'],
'Message' => $fields['msg'],
'Error Number' => $errno,
'Level' => $level
);
switch( $fields['URI'] ) {
case 'arg:/_xml':
$msg['Input'] = 'XML';
break;
case 'arg:/_xsl':
$msg['Input'] = 'XSL';
break;
default:
$msg['Input'] = $fields['URI'];
}
$msg['Line'] = $fields['line'];
} else {
$msg = array(
'Message Type' => 'Error',
'Error Number' => $errno,
'Level' => $level,
'Fields' => var_export( $fields, TRUE )
);
}
$error_details = $msg['Message Type'] . ' in XSLT Transformation' . "\n"
. '' . "\n";
foreach( $msg as $label => $details ) {
$error_details .= '' . $label . ': | ' . htmlentities( $details ) . ' |
' . "\n";
}
$error_details .= '
';
trigger_error( $error_details, E_USER_ERROR );
}
/**
* Returns the AXMLS Schema Version of the requested XML schema file.
*
* Call this method to obtain the AXMLS DTD version of the requested XML schema file.
* @see SchemaStringVersion()
*
* @param string $filename AXMLS schema file
* @return string Schema version number or FALSE on error
*/
function SchemaFileVersion( $filename ) {
// Open the file
if( !($fp = fopen( $filename, 'r' )) ) {
// die( 'Unable to open file' );
return FALSE;
}
// Process the file
while( $data = fread( $fp, 4096 ) ) {
if( preg_match( $this->versionRegex, $data, $matches ) ) {
return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
}
}
return FALSE;
}
/**
* Returns the AXMLS Schema Version of the provided XML schema string.
*
* Call this method to obtain the AXMLS DTD version of the provided XML schema string.
* @see SchemaFileVersion()
*
* @param string $xmlstring XML schema string
* @return string Schema version number or FALSE on error
*/
function SchemaStringVersion( $xmlstring ) {
if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
return FALSE;
}
if( preg_match( $this->versionRegex, $xmlstring, $matches ) ) {
return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
}
return FALSE;
}
/**
* Extracts an XML schema from an existing database.
*
* Call this method to create an XML schema string from an existing database.
* If the data parameter is set to TRUE, AXMLS will include the data from the database
* in the schema.
*
* @param boolean $data Include data in schema dump
* @indent string indentation to use
* @prefix string extract only tables with given prefix
* @stripprefix strip prefix string when storing in XML schema
* @return string Generated XML schema
*/
function ExtractSchema( $data = FALSE, $indent = ' ', $prefix = '' , $stripprefix=false) {
$old_mode = $this->db->SetFetchMode( ADODB_FETCH_NUM );
$schema = '' . "\n"
. '' . "\n";
if( is_array( $tables = $this->db->MetaTables( 'TABLES' ,false ,($prefix) ? str_replace('_','\_',$prefix).'%' : '') ) ) {
foreach( $tables as $table ) {
$schema .= $indent
. '' . "\n";
// grab details from database
$rs = $this->db->Execute( 'SELECT * FROM ' . $table . ' WHERE -1' );
$fields = $this->db->MetaColumns( $table );
$indexes = $this->db->MetaIndexes( $table );
if( is_array( $fields ) ) {
foreach( $fields as $details ) {
$extra = '';
$content = array();
if( isset($details->max_length) && $details->max_length > 0 ) {
$extra .= ' size="' . $details->max_length . '"';
}
if( isset($details->primary_key) && $details->primary_key ) {
$content[] = '';
} elseif( isset($details->not_null) && $details->not_null ) {
$content[] = '';
}
if( isset($details->has_default) && $details->has_default ) {
$content[] = '';
}
if( isset($details->auto_increment) && $details->auto_increment ) {
$content[] = '';
}
if( isset($details->unsigned) && $details->unsigned ) {
$content[] = '';
}
// this stops the creation of 'R' columns,
// AUTOINCREMENT is used to create auto columns
$details->primary_key = 0;
$type = $rs->MetaType( $details );
$schema .= str_repeat( $indent, 2 ) . '' . "\n";
} else {
$schema .= "/>\n";
}
}
}
if( is_array( $indexes ) ) {
foreach( $indexes as $index => $details ) {
$schema .= str_repeat( $indent, 2 ) . '' . "\n";
if( $details['unique'] ) {
$schema .= str_repeat( $indent, 3 ) . '' . "\n";
}
foreach( $details['columns'] as $column ) {
$schema .= str_repeat( $indent, 3 ) . '' . htmlentities( $column ) . '' . "\n";
}
$schema .= str_repeat( $indent, 2 ) . '' . "\n";
}
}
if( $data ) {
$rs = $this->db->Execute( 'SELECT * FROM ' . $table );
if( is_object( $rs ) && !$rs->EOF ) {
$schema .= str_repeat( $indent, 2 ) . "\n";
while( $row = $rs->FetchRow() ) {
foreach( $row as $key => $val ) {
if ( $val != htmlentities( $val ) ) {
$row[$key] = '';
}
}
$schema .= str_repeat( $indent, 3 ) . '' . implode( '', $row ) . "
\n";
}
$schema .= str_repeat( $indent, 2 ) . "\n";
}
}
$schema .= $indent . "
\n";
}
}
$this->db->SetFetchMode( $old_mode );
$schema .= '';
return $schema;
}
/**
* Sets a prefix for database objects
*
* Call this method to set a standard prefix that will be prepended to all database tables
* and indices when the schema is parsed. Calling setPrefix with no arguments clears the prefix.
*
* @param string $prefix Prefix that will be prepended.
* @param boolean $underscore If TRUE, automatically append an underscore character to the prefix.
* @return boolean TRUE if successful, else FALSE
*/
function SetPrefix( $prefix = '', $underscore = TRUE ) {
switch( TRUE ) {
// clear prefix
case empty( $prefix ):
logMsg( 'Cleared prefix' );
$this->objectPrefix = '';
return TRUE;
// prefix too long
case strlen( $prefix ) > XMLS_PREFIX_MAXLEN:
// prefix contains invalid characters
case !preg_match( '/^[a-z][a-z0-9_]+$/i', $prefix ):
logMsg( 'Invalid prefix: ' . $prefix );
return FALSE;
}
if( $underscore AND substr( $prefix, -1 ) != '_' ) {
$prefix .= '_';
}
// prefix valid
logMsg( 'Set prefix: ' . $prefix );
$this->objectPrefix = $prefix;
return TRUE;
}
/**
* Returns an object name with the current prefix prepended.
*
* @param string $name Name
* @return string Prefixed name
*
* @access private
*/
function prefix( $name = '' ) {
// if prefix is set
if( !empty( $this->objectPrefix ) ) {
// Prepend the object prefix to the table name
// prepend after quote if used
return preg_replace( '/^(`?)(.+)$/', '$1' . $this->objectPrefix . '$2', $name );
}
// No prefix set. Use name provided.
return $name;
}
/**
* Checks if element references a specific platform
*
* @param string $platform Requested platform
* @returns boolean TRUE if platform check succeeds
*
* @access private
*/
function supportedPlatform( $platform = NULL ) {
if( !empty( $platform ) ) {
$regex = '/(^|\|)' . $this->db->databaseType . '(\||$)/i';
if( preg_match( '/^- /', $platform ) ) {
if (preg_match ( $regex, substr( $platform, 2 ) ) ) {
logMsg( 'Platform ' . $platform . ' is NOT supported' );
return FALSE;
}
} else {
if( !preg_match ( $regex, $platform ) ) {
logMsg( 'Platform ' . $platform . ' is NOT supported' );
return FALSE;
}
}
}
logMsg( 'Platform ' . $platform . ' is supported' );
return TRUE;
}
/**
* Clears the array of generated SQL.
*
* @access private
*/
function clearSQL() {
$this->sqlArray = array();
}
/**
* Adds SQL into the SQL array.
*
* @param mixed $sql SQL to Add
* @return boolean TRUE if successful, else FALSE.
*
* @access private
*/
function addSQL( $sql = NULL ) {
if( is_array( $sql ) ) {
foreach( $sql as $line ) {
$this->addSQL( $line );
}
return TRUE;
}
if( is_string( $sql ) ) {
$this->sqlArray[] = $sql;
// if executeInline is enabled, and either no errors have occurred or continueOnError is enabled, execute SQL.
if( $this->ExecuteInline() && ( $this->success == 2 || $this->ContinueOnError() ) ) {
$saved = $this->db->debug;
$this->db->debug = $this->debug;
$ok = $this->db->Execute( $sql );
$this->db->debug = $saved;
if( !$ok ) {
if( $this->debug ) {
ADOConnection::outp( $this->db->ErrorMsg() );
}
$this->success = 1;
}
}
return TRUE;
}
return FALSE;
}
/**
* Gets the SQL array in the specified format.
*
* @param string $format Format
* @return mixed SQL
*
* @access private
*/
function getSQL( $format = NULL, $sqlArray = NULL ) {
if( !is_array( $sqlArray ) ) {
$sqlArray = $this->sqlArray;
}
if( !is_array( $sqlArray ) ) {
return FALSE;
}
switch( strtolower( $format ) ) {
case 'string':
case 'text':
return !empty( $sqlArray ) ? implode( ";\n\n", $sqlArray ) . ';' : '';
case'html':
return !empty( $sqlArray ) ? nl2br( htmlentities( implode( ";\n\n", $sqlArray ) . ';' ) ) : '';
}
return $this->sqlArray;
}
/**
* Destroys an adoSchema object.
*
* Call this method to clean up after an adoSchema object that is no longer in use.
* @deprecated adoSchema now cleans up automatically.
*/
function Destroy() {
if ($this->mgq !== false) {
ini_set('magic_quotes_runtime', $this->mgq );
}
}
}
/**
* Message logging function
*
* @access private
*/
function logMsg( $msg, $title = NULL, $force = FALSE ) {
if( XMLS_DEBUG or $force ) {
echo '';
if( isset( $title ) ) {
echo '' . htmlentities( $title ) . '
';
}
if( @is_object( $this ) ) {
echo '[' . get_class( $this ) . '] ';
}
print_r( $msg );
echo '
';
}
}
PK P:]`| | adodb-perf.inc.phpnu W+A = minimum number of secs to run
// returns in K the memory of current process, or 0 if not known
function adodb_getmem()
{
if (function_exists('memory_get_usage'))
return (integer) ((memory_get_usage()+512)/1024);
$pid = getmypid();
if ( strncmp(strtoupper(PHP_OS),'WIN',3)==0) {
$output = array();
exec('tasklist /FI "PID eq ' . $pid. '" /FO LIST', $output);
return substr($output[5], strpos($output[5], ':') + 1);
}
/* Hopefully UNIX */
exec("ps --pid $pid --no-headers -o%mem,size", $output);
if (sizeof($output) == 0) return 0;
$memarr = explode(' ',$output[0]);
if (sizeof($memarr)>=2) return (integer) $memarr[1];
return 0;
}
// avoids localization problems where , is used instead of .
function adodb_round($n,$prec)
{
return number_format($n, $prec, '.', '');
}
/* obsolete: return microtime value as a float. Retained for backward compat */
function adodb_microtime()
{
return microtime(true);
}
/* sql code timing */
function adodb_log_sql(&$connx,$sql,$inputarr)
{
$perf_table = adodb_perf::table();
$connx->fnExecute = false;
$a0 = microtime(true);
$rs = $connx->Execute($sql,$inputarr);
$a1 = microtime(true);
if (!empty($connx->_logsql) && (empty($connx->_logsqlErrors) || !$rs)) {
global $ADODB_LOG_CONN;
if (!empty($ADODB_LOG_CONN)) {
$conn = $ADODB_LOG_CONN;
if ($conn->databaseType != $connx->databaseType)
$prefix = '/*dbx='.$connx->databaseType .'*/ ';
else
$prefix = '';
} else {
$conn = $connx;
$prefix = '';
}
$conn->_logsql = false; // disable logsql error simulation
$dbT = $conn->databaseType;
$time = $a1 - $a0;
if (!$rs) {
$errM = $connx->ErrorMsg();
$errN = $connx->ErrorNo();
$conn->lastInsID = 0;
$tracer = substr('ERROR: '.htmlspecialchars($errM),0,250);
} else {
$tracer = '';
$errM = '';
$errN = 0;
$dbg = $conn->debug;
$conn->debug = false;
if (!is_object($rs) || $rs->dataProvider == 'empty')
$conn->_affected = $conn->affected_rows(true);
$conn->lastInsID = @$conn->Insert_ID();
$conn->debug = $dbg;
}
if (isset($_SERVER['HTTP_HOST'])) {
$tracer .= '
'.$_SERVER['HTTP_HOST'];
if (isset($_SERVER['PHP_SELF'])) $tracer .= htmlspecialchars($_SERVER['PHP_SELF']);
} else
if (isset($_SERVER['PHP_SELF'])) $tracer .= '
'.htmlspecialchars($_SERVER['PHP_SELF']);
//$tracer .= (string) adodb_backtrace(false);
$tracer = (string) substr($tracer,0,500);
if (is_array($inputarr)) {
if (is_array(reset($inputarr))) $params = 'Array sizeof='.sizeof($inputarr);
else {
// Quote string parameters so we can see them in the
// performance stats. This helps spot disabled indexes.
$xar_params = $inputarr;
foreach ($xar_params as $xar_param_key => $xar_param) {
if (gettype($xar_param) == 'string')
$xar_params[$xar_param_key] = '"' . $xar_param . '"';
}
$params = implode(', ', $xar_params);
if (strlen($params) >= 3000) $params = substr($params, 0, 3000);
}
} else {
$params = '';
}
if (is_array($sql)) $sql = $sql[0];
if ($prefix) $sql = $prefix.$sql;
$arr = array('b'=>strlen($sql).'.'.crc32($sql),
'c'=>substr($sql,0,3900), 'd'=>$params,'e'=>$tracer,'f'=>adodb_round($time,6));
//var_dump($arr);
$saved = $conn->debug;
$conn->debug = 0;
$d = $conn->sysTimeStamp;
if (empty($d)) $d = date("'Y-m-d H:i:s'");
if ($conn->dataProvider == 'oci8' && $dbT != 'oci8po') {
$isql = "insert into $perf_table values($d,:b,:c,:d,:e,:f)";
} else if ($dbT == 'mssqlnative' || $dbT == 'odbc_mssql' || $dbT == 'informix' || strncmp($dbT,'odbtp',4)==0) {
$timer = $arr['f'];
if ($dbT == 'informix') $sql2 = substr($sql2,0,230);
$sql1 = $conn->qstr($arr['b']);
$sql2 = $conn->qstr($arr['c']);
$params = $conn->qstr($arr['d']);
$tracer = $conn->qstr($arr['e']);
$isql = "insert into $perf_table (created,sql0,sql1,params,tracer,timer) values($d,$sql1,$sql2,$params,$tracer,$timer)";
if ($dbT == 'informix') $isql = str_replace(chr(10),' ',$isql);
$arr = false;
} else {
if ($dbT == 'db2') $arr['f'] = (float) $arr['f'];
$isql = "insert into $perf_table (created,sql0,sql1,params,tracer,timer) values( $d,?,?,?,?,?)";
}
global $ADODB_PERF_MIN;
if ($errN != 0 || $time >= $ADODB_PERF_MIN) {
if($conn instanceof ADODB_mysqli && $conn->_queryID) {
mysqli_free_result($conn->_queryID);
}
$ok = $conn->Execute($isql,$arr);
} else
$ok = true;
$conn->debug = $saved;
if ($ok) {
$conn->_logsql = true;
} else {
$err2 = $conn->ErrorMsg();
$conn->_logsql = true; // enable logsql error simulation
$perf = NewPerfMonitor($conn);
if ($perf) {
if ($perf->CreateLogTable()) $ok = $conn->Execute($isql,$arr);
} else {
$ok = $conn->Execute("create table $perf_table (
created varchar(50),
sql0 varchar(250),
sql1 varchar(4000),
params varchar(3000),
tracer varchar(500),
timer decimal(16,6))");
}
if (!$ok) {
ADOConnection::outp( "LOGSQL Insert Failed: $isql
$err2
");
$conn->_logsql = false;
}
}
$connx->_errorMsg = $errM;
$connx->_errorCode = $errN;
}
$connx->fnExecute = 'adodb_log_sql';
return $rs;
}
/*
The settings data structure is an associative array that database parameter per element.
Each database parameter element in the array is itself an array consisting of:
0: category code, used to group related db parameters
1: either
a. sql string to retrieve value, eg. "select value from v\$parameter where name='db_block_size'",
b. array holding sql string and field to look for, e.g. array('show variables','table_cache'),
c. a string prefixed by =, then a PHP method of the class is invoked,
e.g. to invoke $this->GetIndexValue(), set this array element to '=GetIndexValue',
2: description of the database parameter
*/
class adodb_perf {
var $conn;
var $color = '#F0F0F0';
var $table = '';
var $titles = 'Parameter | Value | Description |
';
var $warnRatio = 90;
var $tablesSQL = false;
var $cliFormat = "%32s => %s \r\n";
var $sql1 = 'sql1'; // used for casting sql1 to text for mssql
var $explain = true;
var $helpurl = 'LogSQL help';
var $createTableSQL = false;
var $maxLength = 2000;
// Sets the tablename to be used
static function table($newtable = false)
{
static $_table;
if (!empty($newtable)) $_table = $newtable;
if (empty($_table)) $_table = 'adodb_logsql';
return $_table;
}
// returns array with info to calculate CPU Load
function _CPULoad()
{
/*
cpu 524152 2662 2515228 336057010
cpu0 264339 1408 1257951 168025827
cpu1 259813 1254 1257277 168031181
page 622307 25475680
swap 24 1891
intr 890153570 868093576 6 0 4 4 0 6 1 2 0 0 0 124 0 8098760 2 13961053 0 0 0 0 0 0 0 0 0 0 0 0 0 16 16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
disk_io: (3,0):(3144904,54369,610378,3090535,50936192) (3,1):(3630212,54097,633016,3576115,50951320)
ctxt 66155838
btime 1062315585
processes 69293
*/
// Algorithm is taken from
// http://social.technet.microsoft.com/Forums/en-US/winservergen/thread/414b0e1b-499c-411e-8a02-6a12e339c0f1/
if (strncmp(PHP_OS,'WIN',3)==0) {
if (PHP_VERSION == '5.0.0') return false;
if (PHP_VERSION == '5.0.1') return false;
if (PHP_VERSION == '5.0.2') return false;
if (PHP_VERSION == '5.0.3') return false;
if (PHP_VERSION == '4.3.10') return false; # see http://bugs.php.net/bug.php?id=31737
static $FAIL = false;
if ($FAIL) return false;
$objName = "winmgmts:{impersonationLevel=impersonate}!\\\\.\\root\\CIMV2";
$myQuery = "SELECT * FROM Win32_PerfFormattedData_PerfOS_Processor WHERE Name = '_Total'";
try {
@$objWMIService = new COM($objName);
if (!$objWMIService) {
$FAIL = true;
return false;
}
$info[0] = -1;
$info[1] = 0;
$info[2] = 0;
$info[3] = 0;
foreach($objWMIService->ExecQuery($myQuery) as $objItem) {
$info[0] = $objItem->PercentProcessorTime();
}
} catch(Exception $e) {
$FAIL = true;
echo $e->getMessage();
return false;
}
return $info;
}
// Algorithm - Steve Blinch (BlitzAffe Online, http://www.blitzaffe.com)
$statfile = '/proc/stat';
if (!file_exists($statfile)) return false;
$fd = fopen($statfile,"r");
if (!$fd) return false;
$statinfo = explode("\n",fgets($fd, 1024));
fclose($fd);
foreach($statinfo as $line) {
$info = explode(" ",$line);
if($info[0]=="cpu") {
array_shift($info); // pop off "cpu"
if(!$info[0]) array_shift($info); // pop off blank space (if any)
return $info;
}
}
return false;
}
/* NOT IMPLEMENTED */
function MemInfo()
{
/*
total: used: free: shared: buffers: cached:
Mem: 1055289344 917299200 137990144 0 165437440 599773184
Swap: 2146775040 11055104 2135719936
MemTotal: 1030556 kB
MemFree: 134756 kB
MemShared: 0 kB
Buffers: 161560 kB
Cached: 581384 kB
SwapCached: 4332 kB
Active: 494468 kB
Inact_dirty: 322856 kB
Inact_clean: 24256 kB
Inact_target: 168316 kB
HighTotal: 131064 kB
HighFree: 1024 kB
LowTotal: 899492 kB
LowFree: 133732 kB
SwapTotal: 2096460 kB
SwapFree: 2085664 kB
Committed_AS: 348732 kB
*/
}
/*
Remember that this is client load, not db server load!
*/
var $_lastLoad;
function CPULoad()
{
$info = $this->_CPULoad();
if (!$info) return false;
if (strncmp(PHP_OS,'WIN',3)==0) {
return (integer) $info[0];
}else {
if (empty($this->_lastLoad)) {
sleep(1);
$this->_lastLoad = $info;
$info = $this->_CPULoad();
}
$last = $this->_lastLoad;
$this->_lastLoad = $info;
$d_user = $info[0] - $last[0];
$d_nice = $info[1] - $last[1];
$d_system = $info[2] - $last[2];
$d_idle = $info[3] - $last[3];
//printf("Delta - User: %f Nice: %f System: %f Idle: %f
",$d_user,$d_nice,$d_system,$d_idle);
$total=$d_user+$d_nice+$d_system+$d_idle;
if ($total<1) $total=1;
return 100*($d_user+$d_nice+$d_system)/$total;
}
}
function Tracer($sql)
{
$perf_table = adodb_perf::table();
$saveE = $this->conn->fnExecute;
$this->conn->fnExecute = false;
global $ADODB_FETCH_MODE;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$sqlq = $this->conn->qstr($sql);
$arr = $this->conn->GetArray(
"select count(*),tracer
from $perf_table where sql1=$sqlq
group by tracer
order by 1 desc");
$s = '';
if ($arr) {
$s .= 'Scripts Affected
';
foreach($arr as $k) {
$s .= sprintf("%4d",$k[0]).' '.strip_tags($k[1]).'
';
}
}
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_CACHE_MODE = $save;
$this->conn->fnExecute = $saveE;
return $s;
}
/*
Explain Plan for $sql.
If only a snippet of the $sql is passed in, then $partial will hold the crc32 of the
actual sql.
*/
function Explain($sql,$partial=false)
{
return false;
}
function InvalidSQL($numsql = 10)
{
if (isset($_GET['sql'])) return;
$s = 'Invalid SQL
';
$saveE = $this->conn->fnExecute;
$this->conn->fnExecute = false;
$perf_table = adodb_perf::table();
$rs = $this->conn->SelectLimit("select distinct count(*),sql1,tracer as error_msg from $perf_table where tracer like 'ERROR:%' group by sql1,tracer order by 1 desc",$numsql);//,$numsql);
$this->conn->fnExecute = $saveE;
if ($rs) {
$s .= rs2html($rs,false,false,false,false);
} else
return "$this->helpurl. ".$this->conn->ErrorMsg()."
";
return $s;
}
/*
This script identifies the longest running SQL
*/
function _SuspiciousSQL($numsql = 10)
{
global $ADODB_FETCH_MODE;
$perf_table = adodb_perf::table();
$saveE = $this->conn->fnExecute;
$this->conn->fnExecute = false;
if (isset($_GET['exps']) && isset($_GET['sql'])) {
$partial = !empty($_GET['part']);
echo "".$this->Explain($_GET['sql'],$partial)."\n";
}
if (isset($_GET['sql'])) return;
$sql1 = $this->sql1;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
//$this->conn->debug=1;
$rs = $this->conn->SelectLimit(
"select avg(timer) as avg_timer,$sql1,count(*),max(timer) as max_timer,min(timer) as min_timer
from $perf_table
where {$this->conn->upperCase}({$this->conn->substr}(sql0,1,5)) not in ('DROP ','INSER','COMMI','CREAT')
and (tracer is null or tracer not like 'ERROR:%')
group by sql1
order by 1 desc",$numsql);
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_FETCH_MODE = $save;
$this->conn->fnExecute = $saveE;
if (!$rs) return "$this->helpurl. ".$this->conn->ErrorMsg()."
";
$s = "Suspicious SQL
The following SQL have high average execution times
Avg Time | Count | SQL | Max | Min |
\n";
$max = $this->maxLength;
while (!$rs->EOF) {
$sql = $rs->fields[1];
$raw = urlencode($sql);
if (strlen($raw)>$max-100) {
$sql2 = substr($sql,0,$max-500);
$raw = urlencode($sql2).'&part='.crc32($sql);
}
$prefix = "";
$suffix = "";
if ($this->explain == false || strlen($prefix)>$max) {
$suffix = ' ... String too long for GET parameter: '.strlen($prefix).'';
$prefix = '';
}
$s .= "".adodb_round($rs->fields[0],6)." | ".$rs->fields[2]." | ".$prefix.htmlspecialchars($sql).$suffix."".
" | ".$rs->fields[3]." | ".$rs->fields[4]." |
";
$rs->MoveNext();
}
return $s."
";
}
function CheckMemory()
{
return '';
}
function SuspiciousSQL($numsql=10)
{
return adodb_perf::_SuspiciousSQL($numsql);
}
function ExpensiveSQL($numsql=10)
{
return adodb_perf::_ExpensiveSQL($numsql);
}
/*
This reports the percentage of load on the instance due to the most
expensive few SQL statements. Tuning these statements can often
make huge improvements in overall system performance.
*/
function _ExpensiveSQL($numsql = 10)
{
global $ADODB_FETCH_MODE;
$perf_table = adodb_perf::table();
$saveE = $this->conn->fnExecute;
$this->conn->fnExecute = false;
if (isset($_GET['expe']) && isset($_GET['sql'])) {
$partial = !empty($_GET['part']);
echo "".$this->Explain($_GET['sql'],$partial)."\n";
}
if (isset($_GET['sql'])) return;
$sql1 = $this->sql1;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$rs = $this->conn->SelectLimit(
"select sum(timer) as total,$sql1,count(*),max(timer) as max_timer,min(timer) as min_timer
from $perf_table
where {$this->conn->upperCase}({$this->conn->substr}(sql0,1,5)) not in ('DROP ','INSER','COMMI','CREAT')
and (tracer is null or tracer not like 'ERROR:%')
group by sql1
having count(*)>1
order by 1 desc",$numsql);
if (isset($savem)) $this->conn->SetFetchMode($savem);
$this->conn->fnExecute = $saveE;
$ADODB_FETCH_MODE = $save;
if (!$rs) return "$this->helpurl. ".$this->conn->ErrorMsg()."
";
$s = "Expensive SQL
Tuning the following SQL could reduce the server load substantially
Load | Count | SQL | Max | Min |
\n";
$max = $this->maxLength;
while (!$rs->EOF) {
$sql = $rs->fields[1];
$raw = urlencode($sql);
if (strlen($raw)>$max-100) {
$sql2 = substr($sql,0,$max-500);
$raw = urlencode($sql2).'&part='.crc32($sql);
}
$prefix = "";
$suffix = "";
if($this->explain == false || strlen($prefix>$max)) {
$prefix = '';
$suffix = '';
}
$s .= "".adodb_round($rs->fields[0],6)." | ".$rs->fields[2]." | ".$prefix.htmlspecialchars($sql).$suffix."".
" | ".$rs->fields[3]." | ".$rs->fields[4]." |
";
$rs->MoveNext();
}
return $s."
";
}
/*
Raw function to return parameter value from $settings.
*/
function DBParameter($param)
{
if (empty($this->settings[$param])) return false;
$sql = $this->settings[$param][1];
return $this->_DBParameter($sql);
}
/*
Raw function returning array of poll paramters
*/
function PollParameters()
{
$arr[0] = (float)$this->DBParameter('data cache hit ratio');
$arr[1] = (float)$this->DBParameter('data reads');
$arr[2] = (float)$this->DBParameter('data writes');
$arr[3] = (integer) $this->DBParameter('current connections');
return $arr;
}
/*
Low-level Get Database Parameter
*/
function _DBParameter($sql)
{
$savelog = $this->conn->LogSQL(false);
if (is_array($sql)) {
global $ADODB_FETCH_MODE;
$sql1 = $sql[0];
$key = $sql[1];
if (sizeof($sql)>2) $pos = $sql[2];
else $pos = 1;
if (sizeof($sql)>3) $coef = $sql[3];
else $coef = false;
$ret = false;
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->conn->fetchMode !== false) $savem = $this->conn->SetFetchMode(false);
$rs = $this->conn->Execute($sql1);
if (isset($savem)) $this->conn->SetFetchMode($savem);
$ADODB_FETCH_MODE = $save;
if ($rs) {
while (!$rs->EOF) {
$keyf = reset($rs->fields);
if (trim($keyf) == $key) {
$ret = $rs->fields[$pos];
if ($coef) $ret *= $coef;
break;
}
$rs->MoveNext();
}
$rs->Close();
}
$this->conn->LogSQL($savelog);
return $ret;
} else {
if (strncmp($sql,'=',1) == 0) {
$fn = substr($sql,1);
return $this->$fn();
}
$sql = str_replace('$DATABASE',$this->conn->database,$sql);
$ret = $this->conn->GetOne($sql);
$this->conn->LogSQL($savelog);
return $ret;
}
}
/*
Warn if cache ratio falls below threshold. Displayed in "Description" column.
*/
function WarnCacheRatio($val)
{
if ($val < $this->warnRatio)
return 'Cache ratio should be at least '.$this->warnRatio.'%';
else return '';
}
function clearsql()
{
$perf_table = adodb_perf::table();
$this->conn->Execute("delete from $perf_table where created<".$this->conn->sysTimeStamp);
}
/***********************************************************************************************/
// HIGH LEVEL UI FUNCTIONS
/***********************************************************************************************/
function UI($pollsecs=5)
{
global $ADODB_LOG_CONN;
$perf_table = adodb_perf::table();
$conn = $this->conn;
$app = $conn->host;
if ($conn->host && $conn->database) $app .= ', db=';
$app .= $conn->database;
if ($app) $app .= ', ';
$savelog = $this->conn->LogSQL(false);
$info = $conn->ServerInfo();
if (isset($_GET['clearsql'])) {
$this->clearsql();
}
$this->conn->LogSQL($savelog);
// magic quotes
if (isset($_GET['sql']) && get_magic_quotes_gpc()) {
$_GET['sql'] = $_GET['sql'] = str_replace(array("\\'",'\"'),array("'",'"'),$_GET['sql']);
}
if (!isset($_SESSION['ADODB_PERF_SQL'])) $nsql = $_SESSION['ADODB_PERF_SQL'] = 10;
else $nsql = $_SESSION['ADODB_PERF_SQL'];
$app .= $info['description'];
if (isset($_GET['do'])) $do = $_GET['do'];
else if (isset($_POST['do'])) $do = $_POST['do'];
else if (isset($_GET['sql'])) $do = 'viewsql';
else $do = 'stats';
if (isset($_GET['nsql'])) {
if ($_GET['nsql'] > 0) $nsql = $_SESSION['ADODB_PERF_SQL'] = (integer) $_GET['nsql'];
}
echo "ADOdb Performance Monitor on $app";
if ($do == 'viewsql') $form = " | ";
else $form = " | ";
$allowsql = !defined('ADODB_PERF_NO_RUN_SQL');
global $ADODB_PERF_MIN;
$app .= " (Min sql timing \$ADODB_PERF_MIN=$ADODB_PERF_MIN secs)";
if (empty($_GET['hidem']))
echo "";
switch ($do) {
default:
case 'stats':
if (empty($ADODB_LOG_CONN))
echo " Clear SQL Log
";
echo $this->HealthCheck();
//$this->conn->debug=1;
echo $this->CheckMemory();
break;
case 'poll':
$self = htmlspecialchars($_SERVER['PHP_SELF']);
echo "";
break;
case 'poll2':
echo "
";
$this->Poll($pollsecs);
break;
case 'dosql':
if (!$allowsql) break;
$this->DoSQLForm();
break;
case 'viewsql':
if (empty($_GET['hidem']))
echo " Clear SQL Log
";
echo($this->SuspiciousSQL($nsql));
echo($this->ExpensiveSQL($nsql));
echo($this->InvalidSQL($nsql));
break;
case 'tables':
echo $this->Tables(); break;
}
global $ADODB_vers;
echo "";
}
/*
Runs in infinite loop, returning real-time statistics
*/
function Poll($secs=5)
{
$this->conn->fnExecute = false;
//$this->conn->debug=1;
if ($secs <= 1) $secs = 1;
echo "Accumulating statistics, every $secs seconds...\n";flush();
$arro = $this->PollParameters();
$cnt = 0;
set_time_limit(0);
sleep($secs);
while (1) {
$arr = $this->PollParameters();
$hits = sprintf('%2.2f',$arr[0]);
$reads = sprintf('%12.4f',($arr[1]-$arro[1])/$secs);
$writes = sprintf('%12.4f',($arr[2]-$arro[2])/$secs);
$sess = sprintf('%5d',$arr[3]);
$load = $this->CPULoad();
if ($load !== false) {
$oslabel = 'WS-CPU%';
$osval = sprintf(" %2.1f ",(float) $load);
}else {
$oslabel = '';
$osval = '';
}
if ($cnt % 10 == 0) echo " Time ".$oslabel." Hit% Sess Reads/s Writes/s\n";
$cnt += 1;
echo date('H:i:s').' '.$osval."$hits $sess $reads $writes\n";
flush();
if (connection_aborted()) return;
sleep($secs);
$arro = $arr;
}
}
/*
Returns basic health check in a command line interface
*/
function HealthCheckCLI()
{
return $this->HealthCheck(true);
}
/*
Returns basic health check as HTML
*/
function HealthCheck($cli=false)
{
$saveE = $this->conn->fnExecute;
$this->conn->fnExecute = false;
if ($cli) $html = '';
else $html = $this->table.''.$this->conn->databaseType.' |
'.$this->titles;
$oldc = false;
$bgc = '';
foreach($this->settings as $name => $arr) {
if ($arr === false) break;
if (!is_string($name)) {
if ($cli) $html .= " -- $arr -- \n";
else $html .= "color>$arr |
";
continue;
}
if (!is_array($arr)) break;
$category = $arr[0];
$how = $arr[1];
if (sizeof($arr)>2) $desc = $arr[2];
else $desc = ' ';
if ($category == 'HIDE') continue;
$val = $this->_DBParameter($how);
if ($desc && strncmp($desc,"=",1) === 0) {
$fn = substr($desc,1);
$desc = $this->$fn($val);
}
if ($val === false) {
$m = $this->conn->ErrorMsg();
$val = "Error: $m";
} else {
if (is_numeric($val) && $val >= 256*1024) {
if ($val % (1024*1024) == 0) {
$val /= (1024*1024);
$val .= 'M';
} else if ($val % 1024 == 0) {
$val /= 1024;
$val .= 'K';
}
//$val = htmlspecialchars($val);
}
}
if ($category != $oldc) {
$oldc = $category;
//$bgc = ($bgc == ' bgcolor='.$this->color) ? ' bgcolor=white' : ' bgcolor='.$this->color;
}
if (strlen($desc)==0) $desc = ' ';
if (strlen($val)==0) $val = ' ';
if ($cli) {
$html .= str_replace(' ','',sprintf($this->cliFormat,strip_tags($name),strip_tags($val),strip_tags($desc)));
}else {
$html .= "".$name.' | '.$val.' | '.$desc." |
\n";
}
}
if (!$cli) $html .= "
\n";
$this->conn->fnExecute = $saveE;
return $html;
}
function Tables($orderby='1')
{
if (!$this->tablesSQL) return false;
$savelog = $this->conn->LogSQL(false);
$rs = $this->conn->Execute($this->tablesSQL.' order by '.$orderby);
$this->conn->LogSQL($savelog);
$html = rs2html($rs,false,false,false,false);
return $html;
}
function CreateLogTable()
{
if (!$this->createTableSQL) return false;
$table = $this->table();
$sql = str_replace('adodb_logsql',$table,$this->createTableSQL);
$savelog = $this->conn->LogSQL(false);
$ok = $this->conn->Execute($sql);
$this->conn->LogSQL($savelog);
return ($ok) ? true : false;
}
function DoSQLForm()
{
$PHP_SELF = htmlspecialchars($_SERVER['PHP_SELF']);
$sql = isset($_REQUEST['sql']) ? $_REQUEST['sql'] : '';
if (isset($_SESSION['phplens_sqlrows'])) $rows = $_SESSION['phplens_sqlrows'];
else $rows = 3;
if (isset($_REQUEST['SMALLER'])) {
$rows /= 2;
if ($rows < 3) $rows = 3;
$_SESSION['phplens_sqlrows'] = $rows;
}
if (isset($_REQUEST['BIGGER'])) {
$rows *= 2;
$_SESSION['phplens_sqlrows'] = $rows;
}
?>
undomq(trim($sql));
if (substr($sql,strlen($sql)-1) === ';') {
$print = true;
$sqla = $this->SplitSQL($sql);
} else {
$print = false;
$sqla = array($sql);
}
foreach($sqla as $sqls) {
if (!$sqls) continue;
if ($print) {
print "".htmlspecialchars($sqls)."
";
flush();
}
$savelog = $this->conn->LogSQL(false);
$rs = $this->conn->Execute($sqls);
$this->conn->LogSQL($savelog);
if ($rs && is_object($rs) && !$rs->EOF) {
rs2html($rs);
while ($rs->NextRecordSet()) {
print "";
rs2html($rs);
}
} else {
$e1 = (integer) $this->conn->ErrorNo();
$e2 = $this->conn->ErrorMsg();
if (($e1) || ($e2)) {
if (empty($e1)) $e1 = '-1'; // postgresql fix
print ' '.$e1.': '.$e2;
} else {
print "No Recordset returned
";
}
}
} // foreach
}
function SplitSQL($sql)
{
$arr = explode(';',$sql);
return $arr;
}
function undomq($m)
{
if (get_magic_quotes_gpc()) {
// undo the damage
$m = str_replace('\\\\','\\',$m);
$m = str_replace('\"','"',$m);
$m = str_replace('\\\'','\'',$m);
}
return $m;
}
/************************************************************************/
/**
* Reorganise multiple table-indices/statistics/..
* OptimizeMode could be given by last Parameter
*
* @example
*
* optimizeTables( 'tableA');
*
*
* optimizeTables( 'tableA', 'tableB', 'tableC');
*
*
* optimizeTables( 'tableA', 'tableB', ADODB_OPT_LOW);
*
*
* @param string table name of the table to optimize
* @param int mode optimization-mode
* ADODB_OPT_HIGH
for full optimization
* ADODB_OPT_LOW
for CPU-less optimization
* Default is LOW ADODB_OPT_LOW
* @author Markus Staab
* @return Returns true
on success and false
on error
*/
function OptimizeTables()
{
$args = func_get_args();
$numArgs = func_num_args();
if ( $numArgs == 0) return false;
$mode = ADODB_OPT_LOW;
$lastArg = $args[ $numArgs - 1];
if ( !is_string($lastArg)) {
$mode = $lastArg;
unset( $args[ $numArgs - 1]);
}
foreach( $args as $table) {
$this->optimizeTable( $table, $mode);
}
}
/**
* Reorganise the table-indices/statistics/.. depending on the given mode.
* Default Implementation throws an error.
*
* @param string table name of the table to optimize
* @param int mode optimization-mode
* ADODB_OPT_HIGH
for full optimization
* ADODB_OPT_LOW
for CPU-less optimization
* Default is LOW ADODB_OPT_LOW
* @author Markus Staab
* @return Returns true
on success and false
on error
*/
function OptimizeTable( $table, $mode = ADODB_OPT_LOW)
{
ADOConnection::outp( sprintf( "%s: '%s' not implemented for driver '%s'
", __CLASS__, __FUNCTION__, $this->conn->databaseType));
return false;
}
/**
* Reorganise current database.
* Default implementation loops over all MetaTables()
and
* optimize each using optmizeTable()
*
* @author Markus Staab
* @return Returns true
on success and false
on error
*/
function optimizeDatabase()
{
$conn = $this->conn;
if ( !$conn) return false;
$tables = $conn->MetaTables( 'TABLES');
if ( !$tables ) return false;
foreach( $tables as $table) {
if ( !$this->optimizeTable( $table)) {
return false;
}
}
return true;
}
// end hack
}
PK PFM lang/adodb-uk.inc.phpnu W+A 'uk',
DB_ERROR => 'невідома помилка',
DB_ERROR_ALREADY_EXISTS => 'вже існує',
DB_ERROR_CANNOT_CREATE => 'неможливо створити',
DB_ERROR_CANNOT_DELETE => 'неможливо видалити',
DB_ERROR_CANNOT_DROP => 'неможливо знищити (drop)',
DB_ERROR_CONSTRAINT => 'порушення умов перевірки',
DB_ERROR_DIVZERO => 'ділення на 0',
DB_ERROR_INVALID => 'неправильно',
DB_ERROR_INVALID_DATE => 'неправильна дата чи час',
DB_ERROR_INVALID_NUMBER => 'неправильне число',
DB_ERROR_MISMATCH => 'помилка',
DB_ERROR_NODBSELECTED => 'не вибрано БД',
DB_ERROR_NOSUCHFIELD => 'не існує поле',
DB_ERROR_NOSUCHTABLE => 'не існує таблиця',
DB_ERROR_NOT_CAPABLE => 'СУБД не в стані',
DB_ERROR_NOT_FOUND => 'не знайдено',
DB_ERROR_NOT_LOCKED => 'не заблоковано',
DB_ERROR_SYNTAX => 'синтаксична помилка',
DB_ERROR_UNSUPPORTED => 'не підтримується',
DB_ERROR_VALUE_COUNT_ON_ROW => 'рахівник значень в стрічці',
DB_ERROR_INVALID_DSN => 'неправильна DSN',
DB_ERROR_CONNECT_FAILED => 'з\'єднання неуспішне',
0 => 'все гаразд', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'надано недостатньо даних',
DB_ERROR_EXTENSION_NOT_FOUND=> 'розширення не знайдено',
DB_ERROR_NOSUCHDB => 'не існує БД',
DB_ERROR_ACCESS_VIOLATION => 'недостатньо прав доступа'
);
PK P`p lang/adodb-pt-br.inc.phpnu W+A 'pt-br',
DB_ERROR => 'erro desconhecido',
DB_ERROR_ALREADY_EXISTS => 'já existe',
DB_ERROR_CANNOT_CREATE => 'impossível criar',
DB_ERROR_CANNOT_DELETE => 'impossível excluír',
DB_ERROR_CANNOT_DROP => 'impossível remover',
DB_ERROR_CONSTRAINT => 'violação do confinamente',
DB_ERROR_DIVZERO => 'divisão por zero',
DB_ERROR_INVALID => 'inválido',
DB_ERROR_INVALID_DATE => 'data ou hora inválida',
DB_ERROR_INVALID_NUMBER => 'número inválido',
DB_ERROR_MISMATCH => 'erro',
DB_ERROR_NODBSELECTED => 'nenhum banco de dados selecionado',
DB_ERROR_NOSUCHFIELD => 'campo inválido',
DB_ERROR_NOSUCHTABLE => 'tabela inexistente',
DB_ERROR_NOT_CAPABLE => 'capacidade inválida para este BD',
DB_ERROR_NOT_FOUND => 'não encontrado',
DB_ERROR_NOT_LOCKED => 'não bloqueado',
DB_ERROR_SYNTAX => 'erro de sintaxe',
DB_ERROR_UNSUPPORTED =>
'não suportado',
DB_ERROR_VALUE_COUNT_ON_ROW => 'a quantidade de colunas não corresponde ao de valores',
DB_ERROR_INVALID_DSN => 'DSN inválido',
DB_ERROR_CONNECT_FAILED => 'falha na conexão',
0 => 'sem erro', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'dados insuficientes',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extensão não encontrada',
DB_ERROR_NOSUCHDB => 'banco de dados não encontrado',
DB_ERROR_ACCESS_VIOLATION => 'permissão insuficiente'
);
PK PΚ lang/adodb-es.inc.phpnu W+A
$ADODB_LANG_ARRAY = array (
'LANG' => 'es',
DB_ERROR => 'error desconocido',
DB_ERROR_ALREADY_EXISTS => 'ya existe',
DB_ERROR_CANNOT_CREATE => 'imposible crear',
DB_ERROR_CANNOT_DELETE => 'imposible borrar',
DB_ERROR_CANNOT_DROP => 'imposible hacer drop',
DB_ERROR_CONSTRAINT => 'violacion de constraint',
DB_ERROR_DIVZERO => 'division por cero',
DB_ERROR_INVALID => 'invalido',
DB_ERROR_INVALID_DATE => 'fecha u hora invalida',
DB_ERROR_INVALID_NUMBER => 'numero invalido',
DB_ERROR_MISMATCH => 'error',
DB_ERROR_NODBSELECTED => 'no hay base de datos seleccionada',
DB_ERROR_NOSUCHFIELD => 'campo invalido',
DB_ERROR_NOSUCHTABLE => 'tabla no existe',
DB_ERROR_NOT_CAPABLE => 'capacidad invalida para esta DB',
DB_ERROR_NOT_FOUND => 'no encontrado',
DB_ERROR_NOT_LOCKED => 'no bloqueado',
DB_ERROR_SYNTAX => 'error de sintaxis',
DB_ERROR_UNSUPPORTED => 'no soportado',
DB_ERROR_VALUE_COUNT_ON_ROW => 'la cantidad de columnas no corresponden a la cantidad de valores',
DB_ERROR_INVALID_DSN => 'DSN invalido',
DB_ERROR_CONNECT_FAILED => 'fallo la conexion',
0 => 'sin error', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'insuficientes datos',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extension no encontrada',
DB_ERROR_NOSUCHDB => 'base de datos no encontrada',
DB_ERROR_ACCESS_VIOLATION => 'permisos insuficientes'
);
PK PA lang/adodb-hu.inc.phpnu W+A
$ADODB_LANG_ARRAY = array (
'LANG' => 'hu',
DB_ERROR => 'ismeretlen hiba',
DB_ERROR_ALREADY_EXISTS => 'már létezik',
DB_ERROR_CANNOT_CREATE => 'nem sikerült létrehozni',
DB_ERROR_CANNOT_DELETE => 'nem sikerült törölni',
DB_ERROR_CANNOT_DROP => 'nem sikerült eldobni',
DB_ERROR_CONSTRAINT => 'szabályok megszegése',
DB_ERROR_DIVZERO => 'osztás nullával',
DB_ERROR_INVALID => 'érvénytelen',
DB_ERROR_INVALID_DATE => 'érvénytelen dátum vagy idő',
DB_ERROR_INVALID_NUMBER => 'érvénytelen szám',
DB_ERROR_MISMATCH => 'nem megfelelő',
DB_ERROR_NODBSELECTED => 'nincs kiválasztott adatbázis',
DB_ERROR_NOSUCHFIELD => 'nincs ilyen mező',
DB_ERROR_NOSUCHTABLE => 'nincs ilyen tábla',
DB_ERROR_NOT_CAPABLE => 'DB backend nem támogatja',
DB_ERROR_NOT_FOUND => 'nem található',
DB_ERROR_NOT_LOCKED => 'nincs lezárva',
DB_ERROR_SYNTAX => 'szintaktikai hiba',
DB_ERROR_UNSUPPORTED => 'nem támogatott',
DB_ERROR_VALUE_COUNT_ON_ROW => 'soron végzett érték számlálás',
DB_ERROR_INVALID_DSN => 'hibás DSN',
DB_ERROR_CONNECT_FAILED => 'sikertelen csatlakozás',
0 => 'nincs hiba', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'túl kevés az adat',
DB_ERROR_EXTENSION_NOT_FOUND=> 'bővítmény nem található',
DB_ERROR_NOSUCHDB => 'nincs ilyen adatbázis',
DB_ERROR_ACCESS_VIOLATION => 'nincs jogosultság'
);
PK PKr lang/adodb-pl.inc.phpnu W+A
$ADODB_LANG_ARRAY = array (
'LANG' => 'pl',
DB_ERROR => 'niezidentyfikowany błąd',
DB_ERROR_ALREADY_EXISTS => 'już istnieją',
DB_ERROR_CANNOT_CREATE => 'nie można stworzyć',
DB_ERROR_CANNOT_DELETE => 'nie można usunąć',
DB_ERROR_CANNOT_DROP => 'nie można porzucić',
DB_ERROR_CONSTRAINT => 'pogwałcenie uprawnień',
DB_ERROR_DIVZERO => 'dzielenie przez zero',
DB_ERROR_INVALID => 'błędny',
DB_ERROR_INVALID_DATE => 'błędna godzina lub data',
DB_ERROR_INVALID_NUMBER => 'błędny numer',
DB_ERROR_MISMATCH => 'niedopasowanie',
DB_ERROR_NODBSELECTED => 'baza danych nie została wybrana',
DB_ERROR_NOSUCHFIELD => 'nie znaleziono pola',
DB_ERROR_NOSUCHTABLE => 'nie znaleziono tabeli',
DB_ERROR_NOT_CAPABLE => 'nie zdolny',
DB_ERROR_NOT_FOUND => 'nie znaleziono',
DB_ERROR_NOT_LOCKED => 'nie zakmnięty',
DB_ERROR_SYNTAX => 'błąd składni',
DB_ERROR_UNSUPPORTED => 'nie obsługuje',
DB_ERROR_VALUE_COUNT_ON_ROW => 'wartość liczona w szeregu',
DB_ERROR_INVALID_DSN => 'błędny DSN',
DB_ERROR_CONNECT_FAILED => 'połączenie nie zostało zrealizowane',
0 => 'brak błędów', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'niedostateczna ilość informacji',
DB_ERROR_EXTENSION_NOT_FOUND=> 'nie znaleziono rozszerzenia',
DB_ERROR_NOSUCHDB => 'nie znaleziono bazy',
DB_ERROR_ACCESS_VIOLATION => 'niedostateczne uprawnienia'
);
PK P { { lang/adodb-ar.inc.phpnu W+A
$ADODB_LANG_ARRAY = array (
'LANG' => 'ar',
DB_ERROR => 'خطأ غير محدد',
DB_ERROR_ALREADY_EXISTS => 'موجود مسبقا',
DB_ERROR_CANNOT_CREATE => 'لا يمكن إنشاء',
DB_ERROR_CANNOT_DELETE => 'لا يمكن حذف',
DB_ERROR_CANNOT_DROP => 'لا يمكن حذف',
DB_ERROR_CONSTRAINT => 'عملية إدخال ممنوعة',
DB_ERROR_DIVZERO => 'عملية التقسيم على صفر',
DB_ERROR_INVALID => 'غير صحيح',
DB_ERROR_INVALID_DATE => 'صيغة وقت أو تاريخ غير صحيحة',
DB_ERROR_INVALID_NUMBER => 'صيغة رقم غير صحيحة',
DB_ERROR_MISMATCH => 'غير متطابق',
DB_ERROR_NODBSELECTED => 'لم يتم إختيار قاعدة البيانات بعد',
DB_ERROR_NOSUCHFIELD => 'ليس هنالك حقل بهذا الاسم',
DB_ERROR_NOSUCHTABLE => 'ليس هنالك جدول بهذا الاسم',
DB_ERROR_NOT_CAPABLE => 'قاعدة البيانات المرتبط بها غير قادرة',
DB_ERROR_NOT_FOUND => 'لم يتم إيجاده',
DB_ERROR_NOT_LOCKED => 'غير مقفول',
DB_ERROR_SYNTAX => 'خطأ في الصيغة',
DB_ERROR_UNSUPPORTED => 'غير مدعوم',
DB_ERROR_VALUE_COUNT_ON_ROW => 'عدد القيم في السجل',
DB_ERROR_INVALID_DSN => 'DSN غير صحيح',
DB_ERROR_CONNECT_FAILED => 'فشل عملية الإتصال',
0 => 'ليس هنالك أخطاء', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'البيانات المزودة غير كافية',
DB_ERROR_EXTENSION_NOT_FOUND=> 'لم يتم إيجاد الإضافة المتعلقة',
DB_ERROR_NOSUCHDB => 'ليس هنالك قاعدة بيانات بهذا الاسم',
DB_ERROR_ACCESS_VIOLATION => 'سماحيات غير كافية'
);
PK P!p p lang/adodb-eo.inc.phpnu W+A 'eo',
DB_ERROR => 'nekonata eraro',
DB_ERROR_ALREADY_EXISTS => 'jam ekzistas',
DB_ERROR_CANNOT_CREATE => 'maleblas krei',
DB_ERROR_CANNOT_DELETE => 'maleblas elimini',
DB_ERROR_CANNOT_DROP => 'maleblas elimini (drop)',
DB_ERROR_CONSTRAINT => 'rompo de kondiĉoj de provo',
DB_ERROR_DIVZERO => 'divido per 0 (nul)',
DB_ERROR_INVALID => 'malregule',
DB_ERROR_INVALID_DATE => 'malregula dato kaj tempo',
DB_ERROR_INVALID_NUMBER => 'malregula nombro',
DB_ERROR_MISMATCH => 'eraro',
DB_ERROR_NODBSELECTED => 'datumbazo ne elektita',
DB_ERROR_NOSUCHFIELD => 'ne ekzistas kampo',
DB_ERROR_NOSUCHTABLE => 'ne ekzistas tabelo',
DB_ERROR_NOT_CAPABLE => 'DBMS ne povas',
DB_ERROR_NOT_FOUND => 'ne trovita',
DB_ERROR_NOT_LOCKED => 'ne blokita',
DB_ERROR_SYNTAX => 'sintaksa eraro',
DB_ERROR_UNSUPPORTED => 'ne apogata',
DB_ERROR_VALUE_COUNT_ON_ROW => 'nombrilo de valoroj en linio',
DB_ERROR_INVALID_DSN => 'malregula DSN-o',
DB_ERROR_CONNECT_FAILED => 'konekto malsukcesa',
0 => 'ĉio bone', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'ne sufiĉe da datumo',
DB_ERROR_EXTENSION_NOT_FOUND=> 'etendo ne trovita',
DB_ERROR_NOSUCHDB => 'datumbazo ne ekzistas',
DB_ERROR_ACCESS_VIOLATION => 'ne sufiĉe da rajto por atingo'
);
PK P"p p lang/adodb-da.inc.phpnu W+A 'da',
DB_ERROR => 'ukendt fejl',
DB_ERROR_ALREADY_EXISTS => 'eksisterer allerede',
DB_ERROR_CANNOT_CREATE => 'kan ikke oprette',
DB_ERROR_CANNOT_DELETE => 'kan ikke slette',
DB_ERROR_CANNOT_DROP => 'kan ikke droppe',
DB_ERROR_CONSTRAINT => 'begrænsning krænket',
DB_ERROR_DIVZERO => 'division med nul',
DB_ERROR_INVALID => 'ugyldig',
DB_ERROR_INVALID_DATE => 'ugyldig dato eller klokkeslet',
DB_ERROR_INVALID_NUMBER => 'ugyldigt tal',
DB_ERROR_MISMATCH => 'mismatch',
DB_ERROR_NODBSELECTED => 'ingen database valgt',
DB_ERROR_NOSUCHFIELD => 'felt findes ikke',
DB_ERROR_NOSUCHTABLE => 'tabel findes ikke',
DB_ERROR_NOT_CAPABLE => 'DB backend opgav',
DB_ERROR_NOT_FOUND => 'ikke fundet',
DB_ERROR_NOT_LOCKED => 'ikke låst',
DB_ERROR_SYNTAX => 'syntaksfejl',
DB_ERROR_UNSUPPORTED => 'ikke understøttet',
DB_ERROR_VALUE_COUNT_ON_ROW => 'resulterende antal felter svarer ikke til forespørgslens antal felter',
DB_ERROR_INVALID_DSN => 'ugyldig DSN',
DB_ERROR_CONNECT_FAILED => 'tilslutning mislykkedes',
0 => 'ingen fejl', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'utilstrækkelige data angivet',
DB_ERROR_EXTENSION_NOT_FOUND=> 'udvidelse ikke fundet',
DB_ERROR_NOSUCHDB => 'database ikke fundet',
DB_ERROR_ACCESS_VIOLATION => 'utilstrækkelige rettigheder'
);
PK PfW W lang/adodb-ru.inc.phpnu W+A 'ru',
DB_ERROR => 'неизвестная ошибка',
DB_ERROR_ALREADY_EXISTS => 'уже существует',
DB_ERROR_CANNOT_CREATE => 'невозможно создать',
DB_ERROR_CANNOT_DELETE => 'невозможно удалить',
DB_ERROR_CANNOT_DROP => 'невозможно удалить (drop)',
DB_ERROR_CONSTRAINT => 'нарушение условий проверки',
DB_ERROR_DIVZERO => 'деление на 0',
DB_ERROR_INVALID => 'неправильно',
DB_ERROR_INVALID_DATE => 'некорректная дата или время',
DB_ERROR_INVALID_NUMBER => 'некорректное число',
DB_ERROR_MISMATCH => 'ошибка',
DB_ERROR_NODBSELECTED => 'БД не выбрана',
DB_ERROR_NOSUCHFIELD => 'не существует поле',
DB_ERROR_NOSUCHTABLE => 'не существует таблица',
DB_ERROR_NOT_CAPABLE => 'СУБД не в состоянии',
DB_ERROR_NOT_FOUND => 'не найдено',
DB_ERROR_NOT_LOCKED => 'не заблокировано',
DB_ERROR_SYNTAX => 'синтаксическая ошибка',
DB_ERROR_UNSUPPORTED => 'не поддерживается',
DB_ERROR_VALUE_COUNT_ON_ROW => 'счетчик значений в строке',
DB_ERROR_INVALID_DSN => 'неправильная DSN',
DB_ERROR_CONNECT_FAILED => 'соединение неуспешно',
0 => 'нет ошибки', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'предоставлено недостаточно данных',
DB_ERROR_EXTENSION_NOT_FOUND=> 'расширение не найдено',
DB_ERROR_NOSUCHDB => 'не существует БД',
DB_ERROR_ACCESS_VIOLATION => 'недостаточно прав доступа'
);
PK PNf[ [ lang/adodb-cn.inc.phpnu W+A 'cn',
DB_ERROR => '未知错误',
DB_ERROR_ALREADY_EXISTS => '已经存在',
DB_ERROR_CANNOT_CREATE => '不能创建',
DB_ERROR_CANNOT_DELETE => '不能删除',
DB_ERROR_CANNOT_DROP => '不能丢弃',
DB_ERROR_CONSTRAINT => '约束限制',
DB_ERROR_DIVZERO => '被0除',
DB_ERROR_INVALID => '无效',
DB_ERROR_INVALID_DATE => '无效的日期或者时间',
DB_ERROR_INVALID_NUMBER => '无效的数字',
DB_ERROR_MISMATCH => '不匹配',
DB_ERROR_NODBSELECTED => '没有数据库被选择',
DB_ERROR_NOSUCHFIELD => '没有相应的字段',
DB_ERROR_NOSUCHTABLE => '没有相应的表',
DB_ERROR_NOT_CAPABLE => '数据库后台不兼容',
DB_ERROR_NOT_FOUND => '没有发现',
DB_ERROR_NOT_LOCKED => '没有被锁定',
DB_ERROR_SYNTAX => '语法错误',
DB_ERROR_UNSUPPORTED => '不支持',
DB_ERROR_VALUE_COUNT_ON_ROW => '在行上累计值',
DB_ERROR_INVALID_DSN => '无效的数据源 (DSN)',
DB_ERROR_CONNECT_FAILED => '连接失败',
0 => '没有错误', // DB_OK
DB_ERROR_NEED_MORE_DATA => '提供的数据不能符合要求',
DB_ERROR_EXTENSION_NOT_FOUND=> '扩展没有被发现',
DB_ERROR_NOSUCHDB => '没有相应的数据库',
DB_ERROR_ACCESS_VIOLATION => '没有合适的权限'
);
PK PУ/3 3 lang/adodb-sv.inc.phpnu W+A 'en',
DB_ERROR => 'Okänt fel',
DB_ERROR_ALREADY_EXISTS => 'finns redan',
DB_ERROR_CANNOT_CREATE => 'kan inte skapa',
DB_ERROR_CANNOT_DELETE => 'kan inte ta bort',
DB_ERROR_CANNOT_DROP => 'kan inte släppa',
DB_ERROR_CONSTRAINT => 'begränsning kränkt',
DB_ERROR_DIVZERO => 'division med noll',
DB_ERROR_INVALID => 'ogiltig',
DB_ERROR_INVALID_DATE => 'ogiltigt datum eller tid',
DB_ERROR_INVALID_NUMBER => 'ogiltigt tal',
DB_ERROR_MISMATCH => 'felaktig matchning',
DB_ERROR_NODBSELECTED => 'ingen databas vald',
DB_ERROR_NOSUCHFIELD => 'inget sådant fält',
DB_ERROR_NOSUCHTABLE => 'ingen sådan tabell',
DB_ERROR_NOT_CAPABLE => 'DB backend klarar det inte',
DB_ERROR_NOT_FOUND => 'finns inte',
DB_ERROR_NOT_LOCKED => 'inte låst',
DB_ERROR_SYNTAX => 'syntaxfel',
DB_ERROR_UNSUPPORTED => 'stöds ej',
DB_ERROR_VALUE_COUNT_ON_ROW => 'värde räknat på rad',
DB_ERROR_INVALID_DSN => 'ogiltig DSN',
DB_ERROR_CONNECT_FAILED => 'anslutning misslyckades',
0 => 'inget fel', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'otillräckligt med data angivet',
DB_ERROR_EXTENSION_NOT_FOUND=> 'utökning hittades ej',
DB_ERROR_NOSUCHDB => 'ingen sådan databas',
DB_ERROR_ACCESS_VIOLATION => 'otillräckliga rättigheter'
);
PK P,ɚ lang/adodb-fa.inc.phpnu W+A */
$ADODB_LANG_ARRAY = array (
'LANG' => 'fa',
DB_ERROR => 'خطای ناشناخته',
DB_ERROR_ALREADY_EXISTS => 'وجود دارد',
DB_ERROR_CANNOT_CREATE => 'امکان create وجود ندارد',
DB_ERROR_CANNOT_DELETE => 'امکان حذف وجود ندارد',
DB_ERROR_CANNOT_DROP => 'امکان drop وجود ندارد',
DB_ERROR_CONSTRAINT => 'نقض شرط',
DB_ERROR_DIVZERO => 'تقسیم بر صفر',
DB_ERROR_INVALID => 'نامعتبر',
DB_ERROR_INVALID_DATE => 'زمان یا تاریخ نامعتبر',
DB_ERROR_INVALID_NUMBER => 'عدد نامعتبر',
DB_ERROR_MISMATCH => 'عدم مطابقت',
DB_ERROR_NODBSELECTED => 'بانک اطلاعاتی انتخاب نشده است',
DB_ERROR_NOSUCHFIELD => 'چنین ستونی وجود ندارد',
DB_ERROR_NOSUCHTABLE => 'چنین جدولی وجود ندارد',
DB_ERROR_NOT_CAPABLE => 'backend بانک اطلاعاتی قادر نیست',
DB_ERROR_NOT_FOUND => 'پیدا نشد',
DB_ERROR_NOT_LOCKED => 'قفل نشده',
DB_ERROR_SYNTAX => 'خطای دستوری',
DB_ERROR_UNSUPPORTED => 'پشتیبانی نمی شود',
DB_ERROR_VALUE_COUNT_ON_ROW => 'شمارش مقادیر روی ردیف',
DB_ERROR_INVALID_DSN => 'DSN نامعتبر',
DB_ERROR_CONNECT_FAILED => 'ارتباط برقرار نشد',
0 => 'بدون خطا', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'داده ناکافی است',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extension پیدا نشد',
DB_ERROR_NOSUCHDB => 'چنین بانک اطلاعاتی وجود ندارد',
DB_ERROR_ACCESS_VIOLATION => 'حق دسترسی ناکافی'
);
PK P)C lang/adodb-th.inc.phpnu W+A
$ADODB_LANG_ARRAY = array (
'LANG' => 'th',
DB_ERROR => 'error ไม่รู้สาเหตุ',
DB_ERROR_ALREADY_EXISTS => 'มี�?ล้ว',
DB_ERROR_CANNOT_CREATE => 'สร้างไม่ได้',
DB_ERROR_CANNOT_DELETE => 'ลบไม่ได้',
DB_ERROR_CANNOT_DROP => 'drop ไม่ได้',
DB_ERROR_CONSTRAINT => 'constraint violation',
DB_ERROR_DIVZERO => 'หา�?ด้วยสู�?',
DB_ERROR_INVALID => 'ไม่ valid',
DB_ERROR_INVALID_DATE => 'วันที่ เวลา ไม่ valid',
DB_ERROR_INVALID_NUMBER => 'เลขไม่ valid',
DB_ERROR_MISMATCH => 'mismatch',
DB_ERROR_NODBSELECTED => 'ไม่ได้เลือ�?�?านข้อมูล',
DB_ERROR_NOSUCHFIELD => 'ไม่มีฟีลด์นี้',
DB_ERROR_NOSUCHTABLE => 'ไม่มีตารางนี้',
DB_ERROR_NOT_CAPABLE => 'DB backend not capable',
DB_ERROR_NOT_FOUND => 'ไม่พบ',
DB_ERROR_NOT_LOCKED => 'ไม่ได้ล๊อ�?',
DB_ERROR_SYNTAX => 'ผิด syntax',
DB_ERROR_UNSUPPORTED => 'ไม่ support',
DB_ERROR_VALUE_COUNT_ON_ROW => 'value count on row',
DB_ERROR_INVALID_DSN => 'invalid DSN',
DB_ERROR_CONNECT_FAILED => 'ไม่สามารถ connect',
0 => 'no error',
DB_ERROR_NEED_MORE_DATA => 'ข้อมูลไม่เพียงพอ',
DB_ERROR_EXTENSION_NOT_FOUND=> 'ไม่พบ extension',
DB_ERROR_NOSUCHDB => 'ไม่มีข้อมูลนี้',
DB_ERROR_ACCESS_VIOLATION => 'permissions ไม่พอ'
);
PK P86> > lang/adodb-cz.inc.phpnu W+A
$ADODB_LANG_ARRAY = array (
'LANG' => 'cz',
DB_ERROR => 'neznámá chyba',
DB_ERROR_ALREADY_EXISTS => 'ji? existuje',
DB_ERROR_CANNOT_CREATE => 'nelze vytvo?it',
DB_ERROR_CANNOT_DELETE => 'nelze smazat',
DB_ERROR_CANNOT_DROP => 'nelze odstranit',
DB_ERROR_CONSTRAINT => 'poru?ení omezující podmínky',
DB_ERROR_DIVZERO => 'd?lení nulou',
DB_ERROR_INVALID => 'neplatné',
DB_ERROR_INVALID_DATE => 'neplatné datum nebo ?as',
DB_ERROR_INVALID_NUMBER => 'neplatné ?íslo',
DB_ERROR_MISMATCH => 'nesouhlasí',
DB_ERROR_NODBSELECTED => '?ádná databáze není vybrána',
DB_ERROR_NOSUCHFIELD => 'pole nenalezeno',
DB_ERROR_NOSUCHTABLE => 'tabulka nenalezena',
DB_ERROR_NOT_CAPABLE => 'nepodporováno',
DB_ERROR_NOT_FOUND => 'nenalezeno',
DB_ERROR_NOT_LOCKED => 'nezam?eno',
DB_ERROR_SYNTAX => 'syntaktická chyba',
DB_ERROR_UNSUPPORTED => 'nepodporováno',
DB_ERROR_VALUE_COUNT_ON_ROW => '',
DB_ERROR_INVALID_DSN => 'neplatné DSN',
DB_ERROR_CONNECT_FAILED => 'p?ipojení selhalo',
0 => 'bez chyb', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'málo zdrojových dat',
DB_ERROR_EXTENSION_NOT_FOUND=> 'roz?í?ení nenalezeno',
DB_ERROR_NOSUCHDB => 'databáze neexistuje',
DB_ERROR_ACCESS_VIOLATION => 'nedostate?ná práva'
);
PK PL lang/adodb-de.inc.phpnu W+A
$ADODB_LANG_ARRAY = array (
'LANG' => 'de',
DB_ERROR => 'Unbekannter Fehler',
DB_ERROR_ALREADY_EXISTS => 'existiert bereits',
DB_ERROR_CANNOT_CREATE => 'kann nicht erstellen',
DB_ERROR_CANNOT_DELETE => 'kann nicht löschen',
DB_ERROR_CANNOT_DROP => 'Tabelle oder Index konnte nicht gelöscht werden',
DB_ERROR_CONSTRAINT => 'Constraint Verletzung',
DB_ERROR_DIVZERO => 'Division durch Null',
DB_ERROR_INVALID => 'ungültig',
DB_ERROR_INVALID_DATE => 'ungültiges Datum oder Zeit',
DB_ERROR_INVALID_NUMBER => 'ungültige Zahl',
DB_ERROR_MISMATCH => 'Unverträglichkeit',
DB_ERROR_NODBSELECTED => 'keine Dantebank ausgewählt',
DB_ERROR_NOSUCHFIELD => 'Feld nicht vorhanden',
DB_ERROR_NOSUCHTABLE => 'Tabelle nicht vorhanden',
DB_ERROR_NOT_CAPABLE => 'Funktion nicht installiert',
DB_ERROR_NOT_FOUND => 'nicht gefunden',
DB_ERROR_NOT_LOCKED => 'nicht gesperrt',
DB_ERROR_SYNTAX => 'Syntaxfehler',
DB_ERROR_UNSUPPORTED => 'nicht Unterstützt',
DB_ERROR_VALUE_COUNT_ON_ROW => 'Anzahl der zurückgelieferten Felder entspricht nicht der Anzahl der Felder in der Abfrage',
DB_ERROR_INVALID_DSN => 'ungültiger DSN',
DB_ERROR_CONNECT_FAILED => 'Verbindung konnte nicht hergestellt werden',
0 => 'kein Fehler', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'Nicht genügend Daten geliefert',
DB_ERROR_EXTENSION_NOT_FOUND=> 'erweiterung nicht gefunden',
DB_ERROR_NOSUCHDB => 'keine Datenbank',
DB_ERROR_ACCESS_VIOLATION => 'ungenügende Rechte'
);
PK PCK K lang/adodb-fr.inc.phpnu W+A 'fr',
DB_ERROR => 'erreur inconnue',
DB_ERROR_ALREADY_EXISTS => 'existe déjà',
DB_ERROR_CANNOT_CREATE => 'création impossible',
DB_ERROR_CANNOT_DELETE => 'effacement impossible',
DB_ERROR_CANNOT_DROP => 'suppression impossible',
DB_ERROR_CONSTRAINT => 'violation de contrainte',
DB_ERROR_DIVZERO => 'division par zéro',
DB_ERROR_INVALID => 'invalide',
DB_ERROR_INVALID_DATE => 'date ou heure invalide',
DB_ERROR_INVALID_NUMBER => 'nombre invalide',
DB_ERROR_MISMATCH => 'erreur de concordance',
DB_ERROR_NODBSELECTED => 'pas de base de données sélectionnée',
DB_ERROR_NOSUCHFIELD => 'nom de colonne invalide',
DB_ERROR_NOSUCHTABLE => 'table ou vue inexistante',
DB_ERROR_NOT_CAPABLE => 'fonction optionnelle non installée',
DB_ERROR_NOT_FOUND => 'pas trouvé',
DB_ERROR_NOT_LOCKED => 'non verrouillé',
DB_ERROR_SYNTAX => 'erreur de syntaxe',
DB_ERROR_UNSUPPORTED => 'non supporté',
DB_ERROR_VALUE_COUNT_ON_ROW => 'valeur insérée trop grande pour colonne',
DB_ERROR_INVALID_DSN => 'DSN invalide',
DB_ERROR_CONNECT_FAILED => 'échec à la connexion',
0 => "pas d'erreur", // DB_OK
DB_ERROR_NEED_MORE_DATA => 'données fournies insuffisantes',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extension non trouvée',
DB_ERROR_NOSUCHDB => 'base de données inconnue',
DB_ERROR_ACCESS_VIOLATION => 'droits insuffisants'
);
PK P6 lang/adodb-bg.inc.phpnu W+A
*/
$ADODB_LANG_ARRAY = array (
'LANG' => 'bg',
DB_ERROR => 'неизвестна грешка',
DB_ERROR_ALREADY_EXISTS => 'вече съществува',
DB_ERROR_CANNOT_CREATE => 'не може да бъде създадена',
DB_ERROR_CANNOT_DELETE => 'не може да бъде изтрита',
DB_ERROR_CANNOT_DROP => 'не може да бъде унищожена',
DB_ERROR_CONSTRAINT => 'нарушено условие',
DB_ERROR_DIVZERO => 'деление на нула',
DB_ERROR_INVALID => 'неправилно',
DB_ERROR_INVALID_DATE => 'некоректна дата или час',
DB_ERROR_INVALID_NUMBER => 'невалиден номер',
DB_ERROR_MISMATCH => 'погрешна употреба',
DB_ERROR_NODBSELECTED => 'не е избрана база данни',
DB_ERROR_NOSUCHFIELD => 'несъществуващо поле',
DB_ERROR_NOSUCHTABLE => 'несъществуваща таблица',
DB_ERROR_NOT_CAPABLE => 'DB backend not capable',
DB_ERROR_NOT_FOUND => 'не е намерена',
DB_ERROR_NOT_LOCKED => 'не е заключена',
DB_ERROR_SYNTAX => 'грешен синтаксис',
DB_ERROR_UNSUPPORTED => 'не се поддържа',
DB_ERROR_VALUE_COUNT_ON_ROW => 'некоректен брой колони в реда',
DB_ERROR_INVALID_DSN => 'невалиден DSN',
DB_ERROR_CONNECT_FAILED => 'връзката не може да бъде осъществена',
0 => 'няма грешки', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'предоставените данни са недостатъчни',
DB_ERROR_EXTENSION_NOT_FOUND=> 'разширението не е намерено',
DB_ERROR_NOSUCHDB => 'несъществуваща база данни',
DB_ERROR_ACCESS_VIOLATION => 'нямате достатъчно права'
);
PK P5kc c lang/adodb-ro.inc.phpnu W+A */
$ADODB_LANG_ARRAY = array (
'LANG' => 'ro',
DB_ERROR => 'eroare necunoscuta',
DB_ERROR_ALREADY_EXISTS => 'deja exista',
DB_ERROR_CANNOT_CREATE => 'nu se poate creea',
DB_ERROR_CANNOT_DELETE => 'nu se poate sterge',
DB_ERROR_CANNOT_DROP => 'nu se poate executa drop',
DB_ERROR_CONSTRAINT => 'violare de constrain',
DB_ERROR_DIVZERO => 'se divide la zero',
DB_ERROR_INVALID => 'invalid',
DB_ERROR_INVALID_DATE => 'data sau timp invalide',
DB_ERROR_INVALID_NUMBER => 'numar invalid',
DB_ERROR_MISMATCH => 'nepotrivire-mismatch',
DB_ERROR_NODBSELECTED => 'nu exista baza de date selectata',
DB_ERROR_NOSUCHFIELD => 'camp inexistent',
DB_ERROR_NOSUCHTABLE => 'tabela inexistenta',
DB_ERROR_NOT_CAPABLE => 'functie optionala neinstalata',
DB_ERROR_NOT_FOUND => 'negasit',
DB_ERROR_NOT_LOCKED => 'neblocat',
DB_ERROR_SYNTAX => 'eroare de sintaxa',
DB_ERROR_UNSUPPORTED => 'nu e suportat',
DB_ERROR_VALUE_COUNT_ON_ROW => 'valoare prea mare pentru coloana',
DB_ERROR_INVALID_DSN => 'DSN invalid',
DB_ERROR_CONNECT_FAILED => 'conectare esuata',
0 => 'fara eroare', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'data introduse insuficiente',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extensie negasita',
DB_ERROR_NOSUCHDB => 'nu exista baza de date',
DB_ERROR_ACCESS_VIOLATION => 'permisiuni insuficiente'
);
PK P^a lang/adodb-it.inc.phpnu W+A 'it',
DB_ERROR => 'errore sconosciuto',
DB_ERROR_ALREADY_EXISTS => 'esiste già',
DB_ERROR_CANNOT_CREATE => 'non posso creare',
DB_ERROR_CANNOT_DELETE => 'non posso cancellare',
DB_ERROR_CANNOT_DROP => 'non posso eliminare',
DB_ERROR_CONSTRAINT => 'violazione constraint',
DB_ERROR_DIVZERO => 'divisione per zero',
DB_ERROR_INVALID => 'non valido',
DB_ERROR_INVALID_DATE => 'data od ora non valida',
DB_ERROR_INVALID_NUMBER => 'numero non valido',
DB_ERROR_MISMATCH => 'diversi',
DB_ERROR_NODBSELECTED => 'nessun database selezionato',
DB_ERROR_NOSUCHFIELD => 'nessun campo trovato',
DB_ERROR_NOSUCHTABLE => 'nessuna tabella trovata',
DB_ERROR_NOT_CAPABLE => 'DB backend non abilitato',
DB_ERROR_NOT_FOUND => 'non trovato',
DB_ERROR_NOT_LOCKED => 'non bloccato',
DB_ERROR_SYNTAX => 'errore di sintassi',
DB_ERROR_UNSUPPORTED => 'non supportato',
DB_ERROR_VALUE_COUNT_ON_ROW => 'valore inserito troppo grande per una colonna',
DB_ERROR_INVALID_DSN => 'DSN non valido',
DB_ERROR_CONNECT_FAILED => 'connessione fallita',
0 => 'nessun errore', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'dati inseriti insufficienti',
DB_ERROR_EXTENSION_NOT_FOUND=> 'estensione non trovata',
DB_ERROR_NOSUCHDB => 'database non trovato',
DB_ERROR_ACCESS_VIOLATION => 'permessi insufficienti'
);
PK P06d d lang/adodb-nl.inc.phpnu W+A 'nl',
DB_ERROR => 'onbekende fout',
DB_ERROR_ALREADY_EXISTS => 'bestaat al',
DB_ERROR_CANNOT_CREATE => 'kan niet aanmaken',
DB_ERROR_CANNOT_DELETE => 'kan niet wissen',
DB_ERROR_CANNOT_DROP => 'kan niet verwijderen',
DB_ERROR_CONSTRAINT => 'constraint overtreding',
DB_ERROR_DIVZERO => 'poging tot delen door nul',
DB_ERROR_INVALID => 'ongeldig',
DB_ERROR_INVALID_DATE => 'ongeldige datum of tijd',
DB_ERROR_INVALID_NUMBER => 'ongeldig nummer',
DB_ERROR_MISMATCH => 'is incorrect',
DB_ERROR_NODBSELECTED => 'geen database geselecteerd',
DB_ERROR_NOSUCHFIELD => 'onbekend veld',
DB_ERROR_NOSUCHTABLE => 'onbekende tabel',
DB_ERROR_NOT_CAPABLE => 'database systeem is niet tot uitvoer in staat',
DB_ERROR_NOT_FOUND => 'niet gevonden',
DB_ERROR_NOT_LOCKED => 'niet vergrendeld',
DB_ERROR_SYNTAX => 'syntaxis fout',
DB_ERROR_UNSUPPORTED => 'niet ondersteund',
DB_ERROR_VALUE_COUNT_ON_ROW => 'waarde telling op rij',
DB_ERROR_INVALID_DSN => 'ongeldige DSN',
DB_ERROR_CONNECT_FAILED => 'connectie mislukt',
0 => 'geen fout', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'onvoldoende data gegeven',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extensie niet gevonden',
DB_ERROR_NOSUCHDB => 'onbekende database',
DB_ERROR_ACCESS_VIOLATION => 'onvoldoende rechten'
);
PK PZw lang/adodb-en.inc.phpnu W+A 'en',
DB_ERROR => 'unknown error',
DB_ERROR_ALREADY_EXISTS => 'already exists',
DB_ERROR_CANNOT_CREATE => 'can not create',
DB_ERROR_CANNOT_DELETE => 'can not delete',
DB_ERROR_CANNOT_DROP => 'can not drop',
DB_ERROR_CONSTRAINT => 'constraint violation',
DB_ERROR_DIVZERO => 'division by zero',
DB_ERROR_INVALID => 'invalid',
DB_ERROR_INVALID_DATE => 'invalid date or time',
DB_ERROR_INVALID_NUMBER => 'invalid number',
DB_ERROR_MISMATCH => 'mismatch',
DB_ERROR_NODBSELECTED => 'no database selected',
DB_ERROR_NOSUCHFIELD => 'no such field',
DB_ERROR_NOSUCHTABLE => 'no such table',
DB_ERROR_NOT_CAPABLE => 'DB backend not capable',
DB_ERROR_NOT_FOUND => 'not found',
DB_ERROR_NOT_LOCKED => 'not locked',
DB_ERROR_SYNTAX => 'syntax error',
DB_ERROR_UNSUPPORTED => 'not supported',
DB_ERROR_VALUE_COUNT_ON_ROW => 'value count on row',
DB_ERROR_INVALID_DSN => 'invalid DSN',
DB_ERROR_CONNECT_FAILED => 'connect failed',
0 => 'no error', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'insufficient data supplied',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extension not found',
DB_ERROR_NOSUCHDB => 'no such database',
DB_ERROR_ACCESS_VIOLATION => 'insufficient permissions',
DB_ERROR_DEADLOCK => 'deadlock detected',
DB_ERROR_STATEMENT_TIMEOUT => 'statement timeout',
DB_ERROR_SERIALIZATION_FAILURE => 'could not serialize access'
);
PK Pk~ lang/adodb-ca.inc.phpnu W+A 'ca',
DB_ERROR => 'error desconegut',
DB_ERROR_ALREADY_EXISTS => 'ja existeix',
DB_ERROR_CANNOT_CREATE => 'no es pot crear',
DB_ERROR_CANNOT_DELETE => 'no es pot esborrar',
DB_ERROR_CANNOT_DROP => 'no es pot eliminar',
DB_ERROR_CONSTRAINT => 'violació de constraint',
DB_ERROR_DIVZERO => 'divisió per zero',
DB_ERROR_INVALID => 'no és vàlid',
DB_ERROR_INVALID_DATE => 'la data o l\'hora no són vàlides',
DB_ERROR_INVALID_NUMBER => 'el nombre no és vàlid',
DB_ERROR_MISMATCH => 'no hi ha coincidència',
DB_ERROR_NODBSELECTED => 'cap base de dades seleccionada',
DB_ERROR_NOSUCHFIELD => 'camp inexistent',
DB_ERROR_NOSUCHTABLE => 'taula inexistent',
DB_ERROR_NOT_CAPABLE => 'l\'execució secundària de DB no pot',
DB_ERROR_NOT_FOUND => 'no trobat',
DB_ERROR_NOT_LOCKED => 'no blocat',
DB_ERROR_SYNTAX => 'error de sintaxi',
DB_ERROR_UNSUPPORTED => 'no suportat',
DB_ERROR_VALUE_COUNT_ON_ROW => 'el nombre de columnes no coincideix amb el nombre de valors en la fila',
DB_ERROR_INVALID_DSN => 'el DSN no és vàlid',
DB_ERROR_CONNECT_FAILED => 'connexió fallida',
0 => 'cap error', // DB_OK
DB_ERROR_NEED_MORE_DATA => 'les dades subministrades són insuficients',
DB_ERROR_EXTENSION_NOT_FOUND=> 'extensió no trobada',
DB_ERROR_NOSUCHDB => 'base de dades inexistent',
DB_ERROR_ACCESS_VIOLATION => 'permisos insuficients'
);
PK Pxq xsl/remove-0.2.xslnu W+A
ADODB XMLSchema
http://adodb-xmlschema.sourceforge.net
Uninstallation Schema
0.2
PK P۾| xsl/convert-0.2-0.3.xslnu W+A
ADODB XMLSchema
http://adodb-xmlschema.sourceforge.net
0.3
PK P,q xsl/convert-0.2-0.1.xslnu W+A
ADODB XMLSchema
http://adodb-xmlschema.sourceforge.net
0.1
PK PG xsl/convert-0.1-0.2.xslnu W+A
ADODB XMLSchema
http://adodb-xmlschema.sourceforge.net
0.2
PK PsI xsl/remove-0.3.xslnu W+A
ADODB XMLSchema
http://adodb-xmlschema.sourceforge.net
Uninstallation Schema
0.3
PK PH
xsl/convert-0.1-0.3.xslnu W+A
ADODB XMLSchema
http://adodb-xmlschema.sourceforge.net
0.3
PK P}S)g )g
LICENSE.mdnu W+A ADOdb License
=============
The ADOdb Library is dual-licensed, released under both the
[BSD 3-clause](#bsd-3-clause-license) and the
[GNU Lesser General Public License (LGPL) v2.1](#gnu-lesser-general-public-license)
or, at your option, any later version.
In plain English, you do not need to distribute your application in source code form,
nor do you need to distribute ADOdb source code, provided you follow the rest of
terms of the BSD license.
For more information about ADOdb, visit http://adodb.org/
BSD 3-Clause License
--------------------
(c) 2000-2013 John Lim (jlim@natsoft.com)
(c) 2014 Damien Regad, Mark Newnham and the ADOdb community
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
### DISCLAIMER
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
GNU LESSER GENERAL PUBLIC LICENSE
---------------------------------
_Version 2.1, February 1999_
_Copyright © 1991, 1999 Free Software Foundation, Inc._
_51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA_
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
_This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1._
### Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: **(1)** we copyright the
library, and **(2)** we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the “Lesser” General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
“work based on the library” and a “work that uses the library”. The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
### TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
**0.** This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called “this License”).
Each licensee is addressed as “you”.
A “library” means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The “Library”, below, refers to any such software library or work
which has been distributed under these terms. A “work based on the
Library” means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term “modification”.)
“Source code” for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
**1.** You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
**2.** You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
* **a)** The modified work must itself be a software library.
* **b)** You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
* **c)** You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
* **d)** If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
**3.** You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
**4.** You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
**5.** A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a “work that uses the Library”. Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a “work that uses the Library” with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a “work that uses the
library”. The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a “work that uses the Library” uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
**6.** As an exception to the Sections above, you may also combine or
link a “work that uses the Library” with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
* **a)** Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable “work that
uses the Library”, as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
* **b)** Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
* **c)** Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
* **d)** If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
* **e)** Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the “work that uses the
Library” must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
**7.** You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
* **a)** Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
* **b)** Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
**8.** You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
**9.** You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
**10.** Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
**11.** If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
**12.** If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
**13.** The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
“any later version”, you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
**14.** If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
### NO WARRANTY
**15.** BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY “AS IS” WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
**16.** IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
_END OF TERMS AND CONDITIONS_
PK PNG
adodb.inc.phpnu W+A fields is available on EOF
$ADODB_FETCH_MODE, // DEFAULT, NUM, ASSOC or BOTH. Default follows native driver default...
$ADODB_GETONE_EOF,
$ADODB_QUOTE_FIELDNAMES; // Allows you to force quotes (backticks) around field names in queries generated by getinsertsql and getupdatesql.
//==============================================================================================
// GLOBAL SETUP
//==============================================================================================
$ADODB_EXTENSION = defined('ADODB_EXTENSION');
// ********************************************************
// Controls $ADODB_FORCE_TYPE mode. Default is ADODB_FORCE_VALUE (3).
// Used in GetUpdateSql and GetInsertSql functions. Thx to Niko, nuko#mbnet.fi
//
// 0 = ignore empty fields. All empty fields in array are ignored.
// 1 = force null. All empty, php null and string 'null' fields are changed to sql NULL values.
// 2 = force empty. All empty, php null and string 'null' fields are changed to sql empty '' or 0 values.
// 3 = force value. Value is left as it is. Php null and string 'null' are set to sql NULL values and empty fields '' are set to empty '' sql values.
define('ADODB_FORCE_IGNORE',0);
define('ADODB_FORCE_NULL',1);
define('ADODB_FORCE_EMPTY',2);
define('ADODB_FORCE_VALUE',3);
// ********************************************************
if (!$ADODB_EXTENSION || ADODB_EXTENSION < 4.0) {
define('ADODB_BAD_RS','Bad $rs in %s. Connection or SQL invalid. Try using $connection->debug=true;
');
// allow [ ] @ ` " and . in table names
define('ADODB_TABLE_REGEX','([]0-9a-z_\:\"\`\.\@\[-]*)');
// prefetching used by oracle
if (!defined('ADODB_PREFETCH_ROWS')) {
define('ADODB_PREFETCH_ROWS',10);
}
/**
* Fetch mode
*
* Set global variable $ADODB_FETCH_MODE to one of these constants or use
* the SetFetchMode() method to control how recordset fields are returned
* when fetching data.
*
* - NUM: array()
* - ASSOC: array('id' => 456, 'name' => 'john')
* - BOTH: array(0 => 456, 'id' => 456, 1 => 'john', 'name' => 'john')
* - DEFAULT: driver-dependent
*/
define('ADODB_FETCH_DEFAULT', 0);
define('ADODB_FETCH_NUM', 1);
define('ADODB_FETCH_ASSOC', 2);
define('ADODB_FETCH_BOTH', 3);
/**
* Associative array case constants
*
* By defining the ADODB_ASSOC_CASE constant to one of these values, it is
* possible to control the case of field names (associative array's keys)
* when operating in ADODB_FETCH_ASSOC fetch mode.
* - LOWER: $rs->fields['orderid']
* - UPPER: $rs->fields['ORDERID']
* - NATIVE: $rs->fields['OrderID'] (or whatever the RDBMS will return)
*
* The default is to use native case-names.
*
* NOTE: This functionality is not implemented everywhere, it currently
* works only with: mssql, odbc, oci8 and ibase derived drivers
*/
define('ADODB_ASSOC_CASE_LOWER', 0);
define('ADODB_ASSOC_CASE_UPPER', 1);
define('ADODB_ASSOC_CASE_NATIVE', 2);
if (!defined('TIMESTAMP_FIRST_YEAR')) {
define('TIMESTAMP_FIRST_YEAR',100);
}
/**
* AutoExecute constants
* (moved from adodb-pear.inc.php since they are only used in here)
*/
define('DB_AUTOQUERY_INSERT', 1);
define('DB_AUTOQUERY_UPDATE', 2);
// PHP's version scheme makes converting to numbers difficult - workaround
$_adodb_ver = (float) PHP_VERSION;
if ($_adodb_ver >= 5.2) {
define('ADODB_PHPVER',0x5200);
} else if ($_adodb_ver >= 5.0) {
define('ADODB_PHPVER',0x5000);
} else {
die("PHP5 or later required. You are running ".PHP_VERSION);
}
unset($_adodb_ver);
}
/**
Accepts $src and $dest arrays, replacing string $data
*/
function ADODB_str_replace($src, $dest, $data) {
if (ADODB_PHPVER >= 0x4050) {
return str_replace($src,$dest,$data);
}
$s = reset($src);
$d = reset($dest);
while ($s !== false) {
$data = str_replace($s,$d,$data);
$s = next($src);
$d = next($dest);
}
return $data;
}
function ADODB_Setup() {
GLOBAL
$ADODB_vers, // database version
$ADODB_COUNTRECS, // count number of records returned - slows down query
$ADODB_CACHE_DIR, // directory to cache recordsets
$ADODB_FETCH_MODE,
$ADODB_CACHE,
$ADODB_CACHE_CLASS,
$ADODB_FORCE_TYPE,
$ADODB_GETONE_EOF,
$ADODB_QUOTE_FIELDNAMES;
if (empty($ADODB_CACHE_CLASS)) {
$ADODB_CACHE_CLASS = 'ADODB_Cache_File' ;
}
$ADODB_FETCH_MODE = ADODB_FETCH_DEFAULT;
$ADODB_FORCE_TYPE = ADODB_FORCE_VALUE;
$ADODB_GETONE_EOF = null;
if (!isset($ADODB_CACHE_DIR)) {
$ADODB_CACHE_DIR = '/tmp'; //(isset($_ENV['TMP'])) ? $_ENV['TMP'] : '/tmp';
} else {
// do not accept url based paths, eg. http:/ or ftp:/
if (strpos($ADODB_CACHE_DIR,'://') !== false) {
die("Illegal path http:// or ftp://");
}
}
/**
* ADODB version as a string.
*/
$ADODB_vers = 'v5.20.17 31-Mar-2020';
/**
* Determines whether recordset->RecordCount() is used.
* Set to false for highest performance -- RecordCount() will always return -1 then
* for databases that provide "virtual" recordcounts...
*/
if (!isset($ADODB_COUNTRECS)) {
$ADODB_COUNTRECS = true;
}
}
//==============================================================================================
// CHANGE NOTHING BELOW UNLESS YOU ARE DESIGNING ADODB
//==============================================================================================
ADODB_Setup();
//==============================================================================================
// CLASS ADOFieldObject
//==============================================================================================
/**
* Helper class for FetchFields -- holds info on a column
*/
class ADOFieldObject {
var $name = '';
var $max_length=0;
var $type="";
/*
// additional fields by dannym... (danny_milo@yahoo.com)
var $not_null = false;
// actually, this has already been built-in in the postgres, fbsql AND mysql module? ^-^
// so we can as well make not_null standard (leaving it at "false" does not harm anyways)
var $has_default = false; // this one I have done only in mysql and postgres for now ...
// others to come (dannym)
var $default_value; // default, if any, and supported. Check has_default first.
*/
}
function _adodb_safedate($s) {
return str_replace(array("'", '\\'), '', $s);
}
// parse date string to prevent injection attack
// date string will have one quote at beginning e.g. '3434343'
function _adodb_safedateq($s) {
$len = strlen($s);
if ($s[0] !== "'") {
$s2 = "'".$s[0];
} else {
$s2 = "'";
}
for($i=1; $i<$len; $i++) {
$ch = $s[$i];
if ($ch === '\\') {
$s2 .= "'";
break;
} elseif ($ch === "'") {
$s2 .= $ch;
break;
}
$s2 .= $ch;
}
return strlen($s2) == 0 ? 'null' : $s2;
}
// for transaction handling
function ADODB_TransMonitor($dbms, $fn, $errno, $errmsg, $p1, $p2, &$thisConnection) {
//print "Errorno ($fn errno=$errno m=$errmsg) ";
$thisConnection->_transOK = false;
if ($thisConnection->_oldRaiseFn) {
$errfn = $thisConnection->_oldRaiseFn;
$errfn($dbms, $fn, $errno, $errmsg, $p1, $p2,$thisConnection);
}
}
//------------------
// class for caching
class ADODB_Cache_File {
var $createdir = true; // requires creation of temp dirs
function __construct() {
global $ADODB_INCLUDED_CSV;
if (empty($ADODB_INCLUDED_CSV)) {
include_once(ADODB_DIR.'/adodb-csvlib.inc.php');
}
}
// write serialised recordset to cache item/file
function writecache($filename, $contents, $debug, $secs2cache) {
return adodb_write_file($filename, $contents,$debug);
}
// load serialised recordset and unserialise it
function &readcache($filename, &$err, $secs2cache, $rsClass) {
$rs = csv2rs($filename,$err,$secs2cache,$rsClass);
return $rs;
}
// flush all items in cache
function flushall($debug=false) {
global $ADODB_CACHE_DIR;
$rez = false;
if (strlen($ADODB_CACHE_DIR) > 1) {
$rez = $this->_dirFlush($ADODB_CACHE_DIR);
if ($debug) {
ADOConnection::outp( "flushall: $ADODB_CACHE_DIR
\n". $rez."
");
}
}
return $rez;
}
// flush one file in cache
function flushcache($f, $debug=false) {
if (!@unlink($f)) {
if ($debug) {
ADOConnection::outp( "flushcache: failed for $f");
}
}
}
function getdirname($hash) {
global $ADODB_CACHE_DIR;
if (!isset($this->notSafeMode)) {
$this->notSafeMode = !ini_get('safe_mode');
}
return ($this->notSafeMode) ? $ADODB_CACHE_DIR.'/'.substr($hash,0,2) : $ADODB_CACHE_DIR;
}
// create temp directories
function createdir($hash, $debug) {
global $ADODB_CACHE_PERMS;
$dir = $this->getdirname($hash);
if ($this->notSafeMode && !file_exists($dir)) {
$oldu = umask(0);
if (!@mkdir($dir, empty($ADODB_CACHE_PERMS) ? 0771 : $ADODB_CACHE_PERMS)) {
if(!is_dir($dir) && $debug) {
ADOConnection::outp("Cannot create $dir");
}
}
umask($oldu);
}
return $dir;
}
/**
* Private function to erase all of the files and subdirectories in a directory.
*
* Just specify the directory, and tell it if you want to delete the directory or just clear it out.
* Note: $kill_top_level is used internally in the function to flush subdirectories.
*/
function _dirFlush($dir, $kill_top_level = false) {
if(!$dh = @opendir($dir)) return;
while (($obj = readdir($dh))) {
if($obj=='.' || $obj=='..') continue;
$f = $dir.'/'.$obj;
if (strpos($obj,'.cache')) {
@unlink($f);
}
if (is_dir($f)) {
$this->_dirFlush($f, true);
}
}
if ($kill_top_level === true) {
@rmdir($dir);
}
return true;
}
}
//==============================================================================================
// CLASS ADOConnection
//==============================================================================================
/**
* Connection object. For connecting to databases, and executing queries.
*/
abstract class ADOConnection {
//
// PUBLIC VARS
//
var $dataProvider = 'native';
var $databaseType = ''; /// RDBMS currently in use, eg. odbc, mysql, mssql
var $database = ''; /// Name of database to be used.
var $host = ''; /// The hostname of the database server
var $port = ''; /// The port of the database server
var $user = ''; /// The username which is used to connect to the database server.
var $password = ''; /// Password for the username. For security, we no longer store it.
var $debug = false; /// if set to true will output sql statements
var $maxblobsize = 262144; /// maximum size of blobs or large text fields (262144 = 256K)-- some db's die otherwise like foxpro
var $concat_operator = '+'; /// default concat operator -- change to || for Oracle/Interbase
var $substr = 'substr'; /// substring operator
var $length = 'length'; /// string length ofperator
var $random = 'rand()'; /// random function
var $upperCase = 'upper'; /// uppercase function
var $fmtDate = "'Y-m-d'"; /// used by DBDate() as the default date format used by the database
var $fmtTimeStamp = "'Y-m-d, h:i:s A'"; /// used by DBTimeStamp as the default timestamp fmt.
var $true = '1'; /// string that represents TRUE for a database
var $false = '0'; /// string that represents FALSE for a database
var $replaceQuote = "\\'"; /// string to use to replace quotes
var $nameQuote = '"'; /// string to use to quote identifiers and names
var $charSet=false; /// character set to use - only for interbase, postgres and oci8
var $metaDatabasesSQL = '';
var $metaTablesSQL = '';
var $uniqueOrderBy = false; /// All order by columns have to be unique
var $emptyDate = ' ';
var $emptyTimeStamp = ' ';
var $lastInsID = false;
//--
var $hasInsertID = false; /// supports autoincrement ID?
var $hasAffectedRows = false; /// supports affected rows for update/delete?
var $hasTop = false; /// support mssql/access SELECT TOP 10 * FROM TABLE
var $hasLimit = false; /// support pgsql/mysql SELECT * FROM TABLE LIMIT 10
var $readOnly = false; /// this is a readonly database - used by phpLens
var $hasMoveFirst = false; /// has ability to run MoveFirst(), scrolling backwards
var $hasGenID = false; /// can generate sequences using GenID();
var $hasTransactions = true; /// has transactions
//--
var $genID = 0; /// sequence id used by GenID();
var $raiseErrorFn = false; /// error function to call
var $isoDates = false; /// accepts dates in ISO format
var $cacheSecs = 3600; /// cache for 1 hour
// memcache
var $memCache = false; /// should we use memCache instead of caching in files
var $memCacheHost; /// memCache host
var $memCachePort = 11211; /// memCache port
var $memCacheCompress = false; /// Use 'true' to store the item compressed (uses zlib)
var $sysDate = false; /// name of function that returns the current date
var $sysTimeStamp = false; /// name of function that returns the current timestamp
var $sysUTimeStamp = false; // name of function that returns the current timestamp accurate to the microsecond or nearest fraction
var $arrayClass = 'ADORecordSet_array'; /// name of class used to generate array recordsets, which are pre-downloaded recordsets
var $noNullStrings = false; /// oracle specific stuff - if true ensures that '' is converted to ' '
var $numCacheHits = 0;
var $numCacheMisses = 0;
var $pageExecuteCountRows = true;
var $uniqueSort = false; /// indicates that all fields in order by must be unique
var $leftOuter = false; /// operator to use for left outer join in WHERE clause
var $rightOuter = false; /// operator to use for right outer join in WHERE clause
var $ansiOuter = false; /// whether ansi outer join syntax supported
var $autoRollback = false; // autoRollback on PConnect().
var $poorAffectedRows = false; // affectedRows not working or unreliable
var $fnExecute = false;
var $fnCacheExecute = false;
var $blobEncodeType = false; // false=not required, 'I'=encode to integer, 'C'=encode to char
var $rsPrefix = "ADORecordSet_";
var $autoCommit = true; /// do not modify this yourself - actually private
var $transOff = 0; /// temporarily disable transactions
var $transCnt = 0; /// count of nested transactions
var $fetchMode=false;
var $null2null = 'null'; // in autoexecute/getinsertsql/getupdatesql, this value will be converted to a null
var $bulkBind = false; // enable 2D Execute array
//
// PRIVATE VARS
//
var $_oldRaiseFn = false;
var $_transOK = null;
var $_connectionID = false; /// The returned link identifier whenever a successful database connection is made.
var $_errorMsg = false; /// A variable which was used to keep the returned last error message. The value will
/// then returned by the errorMsg() function
var $_errorCode = false; /// Last error code, not guaranteed to be used - only by oci8
var $_queryID = false; /// This variable keeps the last created result link identifier
var $_isPersistentConnection = false; /// A boolean variable to state whether its a persistent connection or normal connection. */
var $_bindInputArray = false; /// set to true if ADOConnection.Execute() permits binding of array parameters.
var $_evalAll = false;
var $_affected = false;
var $_logsql = false;
var $_transmode = ''; // transaction mode
/*
* Additional parameters that may be passed to drivers in the connect string
* Driver must be coded to accept the parameters
*/
protected $connectionParameters = array();
/**
* Adds a parameter to the connection string.
*
* These parameters are added to the connection string when connecting,
* if the driver is coded to use it.
*
* @param string $parameter The name of the parameter to set
* @param string $value The value of the parameter
*
* @return null
*
* @example, for mssqlnative driver ('CharacterSet','UTF-8')
*/
final public function setConnectionParameter($parameter,$value)
{
$this->connectionParameters[$parameter] = $value;
}
static function Version() {
global $ADODB_vers;
// Semantic Version number matching regex
$regex = '^[vV]?(\d+\.\d+\.\d+' // Version number (X.Y.Z) with optional 'V'
. '(?:-(?:' // Optional preprod version: a '-'
. 'dev|' // followed by 'dev'
. '(?:(?:alpha|beta|rc)(?:\.\d+))' // or a preprod suffix and version number
. '))?)(?:\s|$)'; // Whitespace or end of string
if (!preg_match("/$regex/", $ADODB_vers, $matches)) {
// This should normally not happen... Return whatever is between the start
// of the string and the first whitespace (or the end of the string).
self::outp("Invalid version number: '$ADODB_vers'", 'Version');
$regex = '^[vV]?(.*?)(?:\s|$)';
preg_match("/$regex/", $ADODB_vers, $matches);
}
return $matches[1];
}
/**
Get server version info...
@returns An array with 2 elements: $arr['string'] is the description string,
and $arr[version] is the version (also a string).
*/
function ServerInfo() {
return array('description' => '', 'version' => '');
}
function IsConnected() {
return !empty($this->_connectionID);
}
function _findvers($str) {
if (preg_match('/([0-9]+\.([0-9\.])+)/',$str, $arr)) {
return $arr[1];
} else {
return '';
}
}
/**
* All error messages go through this bottleneck function.
* You can define your own handler by defining the function name in ADODB_OUTP.
*/
static function outp($msg,$newline=true) {
global $ADODB_FLUSH,$ADODB_OUTP;
if (defined('ADODB_OUTP')) {
$fn = ADODB_OUTP;
$fn($msg,$newline);
return;
} else if (isset($ADODB_OUTP)) {
$fn = $ADODB_OUTP;
$fn($msg,$newline);
return;
}
if ($newline) {
$msg .= "
\n";
}
if (isset($_SERVER['HTTP_USER_AGENT']) || !$newline) {
echo $msg;
} else {
echo strip_tags($msg);
}
if (!empty($ADODB_FLUSH) && ob_get_length() !== false) {
flush(); // do not flush if output buffering enabled - useless - thx to Jesse Mullan
}
}
function Time() {
$rs = $this->_Execute("select $this->sysTimeStamp");
if ($rs && !$rs->EOF) {
return $this->UnixTimeStamp(reset($rs->fields));
}
return false;
}
/**
* Parses the hostname to extract the port.
* Overwrites $this->host and $this->port, only if a port is specified.
* The Hostname can be fully or partially qualified,
* ie: "db.mydomain.com:5432" or "ldaps://ldap.mydomain.com:636"
* Any specified scheme such as ldap:// or ldaps:// is maintained.
*/
protected function parseHostNameAndPort() {
$parsed_url = parse_url($this->host);
if (is_array($parsed_url) && isset($parsed_url['host']) && isset($parsed_url['port'])) {
if ( isset($parsed_url['scheme']) ) {
// If scheme is specified (ie: ldap:// or ldaps://, make sure we retain that.
$this->host = $parsed_url['scheme'] . "://" . $parsed_url['host'];
} else {
$this->host = $parsed_url['host'];
}
$this->port = $parsed_url['port'];
}
}
/**
* Connect to database
*
* @param [argHostname] Host to connect to
* @param [argUsername] Userid to login
* @param [argPassword] Associated password
* @param [argDatabaseName] database
* @param [forceNew] force new connection
*
* @return true or false
*/
function Connect($argHostname = "", $argUsername = "", $argPassword = "", $argDatabaseName = "", $forceNew = false) {
if ($argHostname != "") {
$this->host = $argHostname;
}
// Overwrites $this->host and $this->port if a port is specified.
$this->parseHostNameAndPort();
if ($argUsername != "") {
$this->user = $argUsername;
}
if ($argPassword != "") {
$this->password = 'not stored'; // not stored for security reasons
}
if ($argDatabaseName != "") {
$this->database = $argDatabaseName;
}
$this->_isPersistentConnection = false;
if ($forceNew) {
if ($rez=$this->_nconnect($this->host, $this->user, $argPassword, $this->database)) {
return true;
}
} else {
if ($rez=$this->_connect($this->host, $this->user, $argPassword, $this->database)) {
return true;
}
}
if (isset($rez)) {
$err = $this->ErrorMsg();
$errno = $this->ErrorNo();
if (empty($err)) {
$err = "Connection error to server '$argHostname' with user '$argUsername'";
}
} else {
$err = "Missing extension for ".$this->dataProvider;
$errno = 0;
}
if ($fn = $this->raiseErrorFn) {
$fn($this->databaseType, 'CONNECT', $errno, $err, $this->host, $this->database, $this);
}
$this->_connectionID = false;
if ($this->debug) {
ADOConnection::outp( $this->host.': '.$err);
}
return false;
}
function _nconnect($argHostname, $argUsername, $argPassword, $argDatabaseName) {
return $this->_connect($argHostname, $argUsername, $argPassword, $argDatabaseName);
}
/**
* Always force a new connection to database - currently only works with oracle
*
* @param [argHostname] Host to connect to
* @param [argUsername] Userid to login
* @param [argPassword] Associated password
* @param [argDatabaseName] database
*
* @return true or false
*/
function NConnect($argHostname = "", $argUsername = "", $argPassword = "", $argDatabaseName = "") {
return $this->Connect($argHostname, $argUsername, $argPassword, $argDatabaseName, true);
}
/**
* Establish persistent connect to database
*
* @param [argHostname] Host to connect to
* @param [argUsername] Userid to login
* @param [argPassword] Associated password
* @param [argDatabaseName] database
*
* @return return true or false
*/
function PConnect($argHostname = "", $argUsername = "", $argPassword = "", $argDatabaseName = "") {
if (defined('ADODB_NEVER_PERSIST')) {
return $this->Connect($argHostname,$argUsername,$argPassword,$argDatabaseName);
}
if ($argHostname != "") {
$this->host = $argHostname;
}
// Overwrites $this->host and $this->port if a port is specified.
$this->parseHostNameAndPort();
if ($argUsername != "") {
$this->user = $argUsername;
}
if ($argPassword != "") {
$this->password = 'not stored';
}
if ($argDatabaseName != "") {
$this->database = $argDatabaseName;
}
$this->_isPersistentConnection = true;
if ($rez = $this->_pconnect($this->host, $this->user, $argPassword, $this->database)) {
return true;
}
if (isset($rez)) {
$err = $this->ErrorMsg();
if (empty($err)) {
$err = "Connection error to server '$argHostname' with user '$argUsername'";
}
$ret = false;
} else {
$err = "Missing extension for ".$this->dataProvider;
$ret = 0;
}
if ($fn = $this->raiseErrorFn) {
$fn($this->databaseType,'PCONNECT',$this->ErrorNo(),$err,$this->host,$this->database,$this);
}
$this->_connectionID = false;
if ($this->debug) {
ADOConnection::outp( $this->host.': '.$err);
}
return $ret;
}
function outp_throw($msg,$src='WARN',$sql='') {
if (defined('ADODB_ERROR_HANDLER') && ADODB_ERROR_HANDLER == 'adodb_throw') {
adodb_throw($this->databaseType,$src,-9999,$msg,$sql,false,$this);
return;
}
ADOConnection::outp($msg);
}
// create cache class. Code is backward compat with old memcache implementation
function _CreateCache() {
global $ADODB_CACHE, $ADODB_CACHE_CLASS;
if ($this->memCache) {
global $ADODB_INCLUDED_MEMCACHE;
if (empty($ADODB_INCLUDED_MEMCACHE)) {
include_once(ADODB_DIR.'/adodb-memcache.lib.inc.php');
}
$ADODB_CACHE = new ADODB_Cache_MemCache($this);
} else {
$ADODB_CACHE = new $ADODB_CACHE_CLASS($this);
}
}
// Format date column in sql string given an input format that understands Y M D
function SQLDate($fmt, $col=false) {
if (!$col) {
$col = $this->sysDate;
}
return $col; // child class implement
}
/**
* Should prepare the sql statement and return the stmt resource.
* For databases that do not support this, we return the $sql. To ensure
* compatibility with databases that do not support prepare:
*
* $stmt = $db->Prepare("insert into table (id, name) values (?,?)");
* $db->Execute($stmt,array(1,'Jill')) or die('insert failed');
* $db->Execute($stmt,array(2,'Joe')) or die('insert failed');
*
* @param sql SQL to send to database
*
* @return return FALSE, or the prepared statement, or the original sql if
* if the database does not support prepare.
*
*/
function Prepare($sql) {
return $sql;
}
/**
* Some databases, eg. mssql require a different function for preparing
* stored procedures. So we cannot use Prepare().
*
* Should prepare the stored procedure and return the stmt resource.
* For databases that do not support this, we return the $sql. To ensure
* compatibility with databases that do not support prepare:
*
* @param sql SQL to send to database
*
* @return return FALSE, or the prepared statement, or the original sql if
* if the database does not support prepare.
*
*/
function PrepareSP($sql,$param=true) {
return $this->Prepare($sql,$param);
}
/**
* PEAR DB Compat
*/
function Quote($s) {
return $this->qstr($s,false);
}
/**
* Requested by "Karsten Dambekalns"
*/
function QMagic($s) {
return $this->qstr($s,get_magic_quotes_gpc());
}
function q(&$s) {
//if (!empty($this->qNull && $s == 'null') {
// return $s;
//}
$s = $this->qstr($s,false);
}
/**
* PEAR DB Compat - do not use internally.
*/
function ErrorNative() {
return $this->ErrorNo();
}
/**
* PEAR DB Compat - do not use internally.
*/
function nextId($seq_name) {
return $this->GenID($seq_name);
}
/**
* Lock a row, will escalate and lock the table if row locking not supported
* will normally free the lock at the end of the transaction
*
* @param $table name of table to lock
* @param $where where clause to use, eg: "WHERE row=12". If left empty, will escalate to table lock
*/
function RowLock($table,$where,$col='1 as adodbignore') {
return false;
}
function CommitLock($table) {
return $this->CommitTrans();
}
function RollbackLock($table) {
return $this->RollbackTrans();
}
/**
* PEAR DB Compat - do not use internally.
*
* The fetch modes for NUMERIC and ASSOC for PEAR DB and ADODB are identical
* for easy porting :-)
*
* @param mode The fetchmode ADODB_FETCH_ASSOC or ADODB_FETCH_NUM
* @returns The previous fetch mode
*/
function SetFetchMode($mode) {
$old = $this->fetchMode;
$this->fetchMode = $mode;
if ($old === false) {
global $ADODB_FETCH_MODE;
return $ADODB_FETCH_MODE;
}
return $old;
}
/**
* PEAR DB Compat - do not use internally.
*/
function Query($sql, $inputarr=false) {
$rs = $this->Execute($sql, $inputarr);
if (!$rs && defined('ADODB_PEAR')) {
return ADODB_PEAR_Error();
}
return $rs;
}
/**
* PEAR DB Compat - do not use internally
*/
function LimitQuery($sql, $offset, $count, $params=false) {
$rs = $this->SelectLimit($sql, $count, $offset, $params);
if (!$rs && defined('ADODB_PEAR')) {
return ADODB_PEAR_Error();
}
return $rs;
}
/**
* PEAR DB Compat - do not use internally
*/
function Disconnect() {
return $this->Close();
}
/**
* Returns a placeholder for query parameters
* e.g. $DB->Param('a') will return
* - '?' for most databases
* - ':a' for Oracle
* - '$1', '$2', etc. for PostgreSQL
* @param string $name parameter's name, false to force a reset of the
* number to 1 (for databases that require positioned
* params such as PostgreSQL; note that ADOdb will
* automatically reset this when executing a query )
* @param string $type (unused)
* @return string query parameter placeholder
*/
function Param($name,$type='C') {
return '?';
}
/*
InParameter and OutParameter are self-documenting versions of Parameter().
*/
function InParameter(&$stmt,&$var,$name,$maxLen=4000,$type=false) {
return $this->Parameter($stmt,$var,$name,false,$maxLen,$type);
}
/*
*/
function OutParameter(&$stmt,&$var,$name,$maxLen=4000,$type=false) {
return $this->Parameter($stmt,$var,$name,true,$maxLen,$type);
}
/*
Usage in oracle
$stmt = $db->Prepare('select * from table where id =:myid and group=:group');
$db->Parameter($stmt,$id,'myid');
$db->Parameter($stmt,$group,'group',64);
$db->Execute();
@param $stmt Statement returned by Prepare() or PrepareSP().
@param $var PHP variable to bind to
@param $name Name of stored procedure variable name to bind to.
@param [$isOutput] Indicates direction of parameter 0/false=IN 1=OUT 2= IN/OUT. This is ignored in oci8.
@param [$maxLen] Holds an maximum length of the variable.
@param [$type] The data type of $var. Legal values depend on driver.
*/
function Parameter(&$stmt,&$var,$name,$isOutput=false,$maxLen=4000,$type=false) {
return false;
}
function IgnoreErrors($saveErrs=false) {
if (!$saveErrs) {
$saveErrs = array($this->raiseErrorFn,$this->_transOK);
$this->raiseErrorFn = false;
return $saveErrs;
} else {
$this->raiseErrorFn = $saveErrs[0];
$this->_transOK = $saveErrs[1];
}
}
/**
* Improved method of initiating a transaction. Used together with CompleteTrans().
* Advantages include:
*
* a. StartTrans/CompleteTrans is nestable, unlike BeginTrans/CommitTrans/RollbackTrans.
* Only the outermost block is treated as a transaction.
* b. CompleteTrans auto-detects SQL errors, and will rollback on errors, commit otherwise.
* c. All BeginTrans/CommitTrans/RollbackTrans inside a StartTrans/CompleteTrans block
* are disabled, making it backward compatible.
*/
function StartTrans($errfn = 'ADODB_TransMonitor') {
if ($this->transOff > 0) {
$this->transOff += 1;
return true;
}
$this->_oldRaiseFn = $this->raiseErrorFn;
$this->raiseErrorFn = $errfn;
$this->_transOK = true;
if ($this->debug && $this->transCnt > 0) {
ADOConnection::outp("Bad Transaction: StartTrans called within BeginTrans");
}
$ok = $this->BeginTrans();
$this->transOff = 1;
return $ok;
}
/**
Used together with StartTrans() to end a transaction. Monitors connection
for sql errors, and will commit or rollback as appropriate.
@autoComplete if true, monitor sql errors and commit and rollback as appropriate,
and if set to false force rollback even if no SQL error detected.
@returns true on commit, false on rollback.
*/
function CompleteTrans($autoComplete = true) {
if ($this->transOff > 1) {
$this->transOff -= 1;
return true;
}
$this->raiseErrorFn = $this->_oldRaiseFn;
$this->transOff = 0;
if ($this->_transOK && $autoComplete) {
if (!$this->CommitTrans()) {
$this->_transOK = false;
if ($this->debug) {
ADOConnection::outp("Smart Commit failed");
}
} else {
if ($this->debug) {
ADOConnection::outp("Smart Commit occurred");
}
}
} else {
$this->_transOK = false;
$this->RollbackTrans();
if ($this->debug) {
ADOCOnnection::outp("Smart Rollback occurred");
}
}
return $this->_transOK;
}
/*
At the end of a StartTrans/CompleteTrans block, perform a rollback.
*/
function FailTrans() {
if ($this->debug)
if ($this->transOff == 0) {
ADOConnection::outp("FailTrans outside StartTrans/CompleteTrans");
} else {
ADOConnection::outp("FailTrans was called");
adodb_backtrace();
}
$this->_transOK = false;
}
/**
Check if transaction has failed, only for Smart Transactions.
*/
function HasFailedTrans() {
if ($this->transOff > 0) {
return $this->_transOK == false;
}
return false;
}
/**
* Execute SQL
*
* @param sql SQL statement to execute, or possibly an array holding prepared statement ($sql[0] will hold sql text)
* @param [inputarr] holds the input data to bind to. Null elements will be set to null.
* @return RecordSet or false
*/
function Execute($sql,$inputarr=false) {
if ($this->fnExecute) {
$fn = $this->fnExecute;
$ret = $fn($this,$sql,$inputarr);
if (isset($ret)) {
return $ret;
}
}
if ($inputarr !== false) {
if (!is_array($inputarr)) {
$inputarr = array($inputarr);
}
$element0 = reset($inputarr);
# is_object check because oci8 descriptors can be passed in
$array_2d = $this->bulkBind && is_array($element0) && !is_object(reset($element0));
//remove extra memory copy of input -mikefedyk
unset($element0);
if (!is_array($sql) && !$this->_bindInputArray) {
// @TODO this would consider a '?' within a string as a parameter...
$sqlarr = explode('?',$sql);
$nparams = sizeof($sqlarr)-1;
if (!$array_2d) {
// When not Bind Bulk - convert to array of arguments list
$inputarr = array($inputarr);
} else {
// Bulk bind - Make sure all list of params have the same number of elements
$countElements = array_map('count', $inputarr);
if (1 != count(array_unique($countElements))) {
$this->outp_throw(
"[bulk execute] Input array has different number of params [" . print_r($countElements, true) . "].",
'Execute'
);
return false;
}
unset($countElements);
}
// Make sure the number of parameters provided in the input
// array matches what the query expects
$element0 = reset($inputarr);
if ($nparams != count($element0)) {
$this->outp_throw(
"Input array has " . count($element0) .
" params, does not match query: '" . htmlspecialchars($sql) . "'",
'Execute'
);
return false;
}
// clean memory
unset($element0);
foreach($inputarr as $arr) {
$sql = ''; $i = 0;
foreach ($arr as $v) {
$sql .= $sqlarr[$i];
// from Ron Baldwin
// Only quote string types
$typ = gettype($v);
if ($typ == 'string') {
//New memory copy of input created here -mikefedyk
$sql .= $this->qstr($v);
} else if ($typ == 'double') {
$sql .= str_replace(',','.',$v); // locales fix so 1.1 does not get converted to 1,1
} else if ($typ == 'boolean') {
$sql .= $v ? $this->true : $this->false;
} else if ($typ == 'object') {
if (method_exists($v, '__toString')) {
$sql .= $this->qstr($v->__toString());
} else {
$sql .= $this->qstr((string) $v);
}
} else if ($v === null) {
$sql .= 'NULL';
} else {
$sql .= $v;
}
$i += 1;
if ($i == $nparams) {
break;
}
} // while
if (isset($sqlarr[$i])) {
$sql .= $sqlarr[$i];
if ($i+1 != sizeof($sqlarr)) {
$this->outp_throw( "Input Array does not match ?: ".htmlspecialchars($sql),'Execute');
}
} else if ($i != sizeof($sqlarr)) {
$this->outp_throw( "Input array does not match ?: ".htmlspecialchars($sql),'Execute');
}
$ret = $this->_Execute($sql);
if (!$ret) {
return $ret;
}
}
} else {
if ($array_2d) {
if (is_string($sql)) {
$stmt = $this->Prepare($sql);
} else {
$stmt = $sql;
}
foreach($inputarr as $arr) {
$ret = $this->_Execute($stmt,$arr);
if (!$ret) {
return $ret;
}
}
} else {
$ret = $this->_Execute($sql,$inputarr);
}
}
} else {
$ret = $this->_Execute($sql,false);
}
return $ret;
}
function _Execute($sql,$inputarr=false) {
// ExecuteCursor() may send non-string queries (such as arrays),
// so we need to ignore those.
if( is_string($sql) ) {
// Strips keyword used to help generate SELECT COUNT(*) queries
// from SQL if it exists.
$sql = ADODB_str_replace( '_ADODB_COUNT', '', $sql );
}
if ($this->debug) {
global $ADODB_INCLUDED_LIB;
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
$this->_queryID = _adodb_debug_execute($this, $sql,$inputarr);
} else {
$this->_queryID = @$this->_query($sql,$inputarr);
}
// ************************
// OK, query executed
// ************************
// error handling if query fails
if ($this->_queryID === false) {
if ($this->debug == 99) {
adodb_backtrace(true,5);
}
$fn = $this->raiseErrorFn;
if ($fn) {
$fn($this->databaseType,'EXECUTE',$this->ErrorNo(),$this->ErrorMsg(),$sql,$inputarr,$this);
}
return false;
}
// return simplified recordset for inserts/updates/deletes with lower overhead
if ($this->_queryID === true) {
$rsclass = $this->rsPrefix.'empty';
$rs = (class_exists($rsclass)) ? new $rsclass(): new ADORecordSet_empty();
return $rs;
}
// return real recordset from select statement
$rsclass = $this->rsPrefix.$this->databaseType;
$rs = new $rsclass($this->_queryID,$this->fetchMode);
$rs->connection = $this; // Pablo suggestion
$rs->Init();
if (is_array($sql)) {
$rs->sql = $sql[0];
} else {
$rs->sql = $sql;
}
if ($rs->_numOfRows <= 0) {
global $ADODB_COUNTRECS;
if ($ADODB_COUNTRECS) {
if (!$rs->EOF) {
$rs = $this->_rs2rs($rs,-1,-1,!is_array($sql));
$rs->_queryID = $this->_queryID;
} else
$rs->_numOfRows = 0;
}
}
return $rs;
}
function CreateSequence($seqname='adodbseq',$startID=1) {
if (empty($this->_genSeqSQL)) {
return false;
}
return $this->Execute(sprintf($this->_genSeqSQL,$seqname,$startID));
}
function DropSequence($seqname='adodbseq') {
if (empty($this->_dropSeqSQL)) {
return false;
}
return $this->Execute(sprintf($this->_dropSeqSQL,$seqname));
}
/**
* Generates a sequence id and stores it in $this->genID;
* GenID is only available if $this->hasGenID = true;
*
* @param seqname name of sequence to use
* @param startID if sequence does not exist, start at this ID
* @return 0 if not supported, otherwise a sequence id
*/
function GenID($seqname='adodbseq',$startID=1) {
if (!$this->hasGenID) {
return 0; // formerly returns false pre 1.60
}
$getnext = sprintf($this->_genIDSQL,$seqname);
$holdtransOK = $this->_transOK;
$save_handler = $this->raiseErrorFn;
$this->raiseErrorFn = '';
@($rs = $this->Execute($getnext));
$this->raiseErrorFn = $save_handler;
if (!$rs) {
$this->_transOK = $holdtransOK; //if the status was ok before reset
$createseq = $this->Execute(sprintf($this->_genSeqSQL,$seqname,$startID));
$rs = $this->Execute($getnext);
}
if ($rs && !$rs->EOF) {
$this->genID = reset($rs->fields);
} else {
$this->genID = 0; // false
}
if ($rs) {
$rs->Close();
}
return $this->genID;
}
/**
* @param $table string name of the table, not needed by all databases (eg. mysql), default ''
* @param $column string name of the column, not needed by all databases (eg. mysql), default ''
* @return the last inserted ID. Not all databases support this.
*/
function Insert_ID($table='',$column='') {
if ($this->_logsql && $this->lastInsID) {
return $this->lastInsID;
}
if ($this->hasInsertID) {
return $this->_insertid($table,$column);
}
if ($this->debug) {
ADOConnection::outp( 'Insert_ID error
');
adodb_backtrace();
}
return false;
}
/**
* Portable Insert ID. Pablo Roca
*
* @return the last inserted ID. All databases support this. But aware possible
* problems in multiuser environments. Heavy test this before deploying.
*/
function PO_Insert_ID($table="", $id="") {
if ($this->hasInsertID){
return $this->Insert_ID($table,$id);
} else {
return $this->GetOne("SELECT MAX($id) FROM $table");
}
}
/**
* @return # rows affected by UPDATE/DELETE
*/
function Affected_Rows() {
if ($this->hasAffectedRows) {
if ($this->fnExecute === 'adodb_log_sql') {
if ($this->_logsql && $this->_affected !== false) {
return $this->_affected;
}
}
$val = $this->_affectedrows();
return ($val < 0) ? false : $val;
}
if ($this->debug) {
ADOConnection::outp( 'Affected_Rows error
',false);
}
return false;
}
/**
* @return the last error message
*/
function ErrorMsg() {
if ($this->_errorMsg) {
return '!! '.strtoupper($this->dataProvider.' '.$this->databaseType).': '.$this->_errorMsg;
} else {
return '';
}
}
/**
* @return the last error number. Normally 0 means no error.
*/
function ErrorNo() {
return ($this->_errorMsg) ? -1 : 0;
}
function MetaError($err=false) {
include_once(ADODB_DIR."/adodb-error.inc.php");
if ($err === false) {
$err = $this->ErrorNo();
}
return adodb_error($this->dataProvider,$this->databaseType,$err);
}
function MetaErrorMsg($errno) {
include_once(ADODB_DIR."/adodb-error.inc.php");
return adodb_errormsg($errno);
}
/**
* @returns an array with the primary key columns in it.
*/
function MetaPrimaryKeys($table, $owner=false) {
// owner not used in base class - see oci8
$p = array();
$objs = $this->MetaColumns($table);
if ($objs) {
foreach($objs as $v) {
if (!empty($v->primary_key)) {
$p[] = $v->name;
}
}
}
if (sizeof($p)) {
return $p;
}
if (function_exists('ADODB_VIEW_PRIMARYKEYS')) {
return ADODB_VIEW_PRIMARYKEYS($this->databaseType, $this->database, $table, $owner);
}
return false;
}
/**
* @returns assoc array where keys are tables, and values are foreign keys
*/
function MetaForeignKeys($table, $owner=false, $upper=false) {
return false;
}
/**
* Choose a database to connect to. Many databases do not support this.
*
* @param dbName is the name of the database to select
* @return true or false
*/
function SelectDB($dbName) {return false;}
/**
* Will select, getting rows from $offset (1-based), for $nrows.
* This simulates the MySQL "select * from table limit $offset,$nrows" , and
* the PostgreSQL "select * from table limit $nrows offset $offset". Note that
* MySQL and PostgreSQL parameter ordering is the opposite of the other.
* eg.
* SelectLimit('select * from table',3); will return rows 1 to 3 (1-based)
* SelectLimit('select * from table',3,2); will return rows 3 to 5 (1-based)
*
* Uses SELECT TOP for Microsoft databases (when $this->hasTop is set)
* BUG: Currently SelectLimit fails with $sql with LIMIT or TOP clause already set
*
* @param sql
* @param [offset] is the row to start calculations from (1-based)
* @param [nrows] is the number of rows to get
* @param [inputarr] array of bind variables
* @param [secs2cache] is a private parameter only used by jlim
* @return the recordset ($rs->databaseType == 'array')
*/
function SelectLimit($sql,$nrows=-1,$offset=-1, $inputarr=false,$secs2cache=0) {
$nrows = (int)$nrows;
$offset = (int)$offset;
if ($this->hasTop && $nrows > 0) {
// suggested by Reinhard Balling. Access requires top after distinct
// Informix requires first before distinct - F Riosa
$ismssql = (strpos($this->databaseType,'mssql') !== false);
if ($ismssql) {
$isaccess = false;
} else {
$isaccess = (strpos($this->databaseType,'access') !== false);
}
if ($offset <= 0) {
// access includes ties in result
if ($isaccess) {
$sql = preg_replace(
'/(^\s*select\s+(distinctrow|distinct)?)/i','\\1 '.$this->hasTop.' '.$nrows.' ',$sql);
if ($secs2cache != 0) {
$ret = $this->CacheExecute($secs2cache, $sql,$inputarr);
} else {
$ret = $this->Execute($sql,$inputarr);
}
return $ret; // PHP5 fix
} else if ($ismssql){
$sql = preg_replace(
'/(^\s*select\s+(distinctrow|distinct)?)/i','\\1 '.$this->hasTop.' '.$nrows.' ',$sql);
} else {
$sql = preg_replace(
'/(^\s*select\s)/i','\\1 '.$this->hasTop.' '.$nrows.' ',$sql);
}
} else {
$nn = $nrows + $offset;
if ($isaccess || $ismssql) {
$sql = preg_replace(
'/(^\s*select\s+(distinctrow|distinct)?)/i','\\1 '.$this->hasTop.' '.$nn.' ',$sql);
} else {
$sql = preg_replace(
'/(^\s*select\s)/i','\\1 '.$this->hasTop.' '.$nn.' ',$sql);
}
}
}
// if $offset>0, we want to skip rows, and $ADODB_COUNTRECS is set, we buffer rows
// 0 to offset-1 which will be discarded anyway. So we disable $ADODB_COUNTRECS.
global $ADODB_COUNTRECS;
$savec = $ADODB_COUNTRECS;
$ADODB_COUNTRECS = false;
if ($secs2cache != 0) {
$rs = $this->CacheExecute($secs2cache,$sql,$inputarr);
} else {
$rs = $this->Execute($sql,$inputarr);
}
$ADODB_COUNTRECS = $savec;
if ($rs && !$rs->EOF) {
$rs = $this->_rs2rs($rs,$nrows,$offset);
}
//print_r($rs);
return $rs;
}
/**
* Create serializable recordset. Breaks rs link to connection.
*
* @param rs the recordset to serialize
*/
function SerializableRS(&$rs) {
$rs2 = $this->_rs2rs($rs);
$ignore = false;
$rs2->connection = $ignore;
return $rs2;
}
/**
* Convert database recordset to an array recordset
* input recordset's cursor should be at beginning, and
* old $rs will be closed.
*
* @param rs the recordset to copy
* @param [nrows] number of rows to retrieve (optional)
* @param [offset] offset by number of rows (optional)
* @return the new recordset
*/
function &_rs2rs(&$rs,$nrows=-1,$offset=-1,$close=true) {
if (! $rs) {
return false;
}
$dbtype = $rs->databaseType;
if (!$dbtype) {
$rs = $rs; // required to prevent crashing in 4.2.1, but does not happen in 4.3.1 -- why ?
return $rs;
}
if (($dbtype == 'array' || $dbtype == 'csv') && $nrows == -1 && $offset == -1) {
$rs->MoveFirst();
$rs = $rs; // required to prevent crashing in 4.2.1, but does not happen in 4.3.1-- why ?
return $rs;
}
$flds = array();
for ($i=0, $max=$rs->FieldCount(); $i < $max; $i++) {
$flds[] = $rs->FetchField($i);
}
$arr = $rs->GetArrayLimit($nrows,$offset);
//print_r($arr);
if ($close) {
$rs->Close();
}
$arrayClass = $this->arrayClass;
$rs2 = new $arrayClass();
$rs2->connection = $this;
$rs2->sql = $rs->sql;
$rs2->dataProvider = $this->dataProvider;
$rs2->InitArrayFields($arr,$flds);
$rs2->fetchMode = isset($rs->adodbFetchMode) ? $rs->adodbFetchMode : $rs->fetchMode;
return $rs2;
}
/*
* Return all rows. Compat with PEAR DB
*/
function GetAll($sql, $inputarr=false) {
$arr = $this->GetArray($sql,$inputarr);
return $arr;
}
function GetAssoc($sql, $inputarr=false,$force_array = false, $first2cols = false) {
$rs = $this->Execute($sql, $inputarr);
if (!$rs) {
return false;
}
$arr = $rs->GetAssoc($force_array,$first2cols);
return $arr;
}
function CacheGetAssoc($secs2cache, $sql=false, $inputarr=false,$force_array = false, $first2cols = false) {
if (!is_numeric($secs2cache)) {
$first2cols = $force_array;
$force_array = $inputarr;
}
$rs = $this->CacheExecute($secs2cache, $sql, $inputarr);
if (!$rs) {
return false;
}
$arr = $rs->GetAssoc($force_array,$first2cols);
return $arr;
}
/**
* Return first element of first row of sql statement. Recordset is disposed
* for you.
*
* @param sql SQL statement
* @param [inputarr] input bind array
*/
function GetOne($sql,$inputarr=false) {
global $ADODB_COUNTRECS,$ADODB_GETONE_EOF;
$crecs = $ADODB_COUNTRECS;
$ADODB_COUNTRECS = false;
$ret = false;
$rs = $this->Execute($sql,$inputarr);
if ($rs) {
if ($rs->EOF) {
$ret = $ADODB_GETONE_EOF;
} else {
$ret = reset($rs->fields);
}
$rs->Close();
}
$ADODB_COUNTRECS = $crecs;
return $ret;
}
// $where should include 'WHERE fld=value'
function GetMedian($table, $field,$where = '') {
$total = $this->GetOne("select count(*) from $table $where");
if (!$total) {
return false;
}
$midrow = (integer) ($total/2);
$rs = $this->SelectLimit("select $field from $table $where order by 1",1,$midrow);
if ($rs && !$rs->EOF) {
return reset($rs->fields);
}
return false;
}
function CacheGetOne($secs2cache,$sql=false,$inputarr=false) {
global $ADODB_GETONE_EOF;
$ret = false;
$rs = $this->CacheExecute($secs2cache,$sql,$inputarr);
if ($rs) {
if ($rs->EOF) {
$ret = $ADODB_GETONE_EOF;
} else {
$ret = reset($rs->fields);
}
$rs->Close();
}
return $ret;
}
function GetCol($sql, $inputarr = false, $trim = false) {
$rs = $this->Execute($sql, $inputarr);
if ($rs) {
$rv = array();
if ($trim) {
while (!$rs->EOF) {
$rv[] = trim(reset($rs->fields));
$rs->MoveNext();
}
} else {
while (!$rs->EOF) {
$rv[] = reset($rs->fields);
$rs->MoveNext();
}
}
$rs->Close();
} else {
$rv = false;
}
return $rv;
}
function CacheGetCol($secs, $sql = false, $inputarr = false,$trim=false) {
$rs = $this->CacheExecute($secs, $sql, $inputarr);
if ($rs) {
$rv = array();
if ($trim) {
while (!$rs->EOF) {
$rv[] = trim(reset($rs->fields));
$rs->MoveNext();
}
} else {
while (!$rs->EOF) {
$rv[] = reset($rs->fields);
$rs->MoveNext();
}
}
$rs->Close();
} else
$rv = false;
return $rv;
}
function Transpose(&$rs,$addfieldnames=true) {
$rs2 = $this->_rs2rs($rs);
if (!$rs2) {
return false;
}
$rs2->_transpose($addfieldnames);
return $rs2;
}
/*
Calculate the offset of a date for a particular database and generate
appropriate SQL. Useful for calculating future/past dates and storing
in a database.
If dayFraction=1.5 means 1.5 days from now, 1.0/24 for 1 hour.
*/
function OffsetDate($dayFraction,$date=false) {
if (!$date) {
$date = $this->sysDate;
}
return '('.$date.'+'.$dayFraction.')';
}
/**
*
* @param sql SQL statement
* @param [inputarr] input bind array
*/
function GetArray($sql,$inputarr=false) {
global $ADODB_COUNTRECS;
$savec = $ADODB_COUNTRECS;
$ADODB_COUNTRECS = false;
$rs = $this->Execute($sql,$inputarr);
$ADODB_COUNTRECS = $savec;
if (!$rs)
if (defined('ADODB_PEAR')) {
$cls = ADODB_PEAR_Error();
return $cls;
} else {
return false;
}
$arr = $rs->GetArray();
$rs->Close();
return $arr;
}
function CacheGetAll($secs2cache,$sql=false,$inputarr=false) {
$arr = $this->CacheGetArray($secs2cache,$sql,$inputarr);
return $arr;
}
function CacheGetArray($secs2cache,$sql=false,$inputarr=false) {
global $ADODB_COUNTRECS;
$savec = $ADODB_COUNTRECS;
$ADODB_COUNTRECS = false;
$rs = $this->CacheExecute($secs2cache,$sql,$inputarr);
$ADODB_COUNTRECS = $savec;
if (!$rs)
if (defined('ADODB_PEAR')) {
$cls = ADODB_PEAR_Error();
return $cls;
} else {
return false;
}
$arr = $rs->GetArray();
$rs->Close();
return $arr;
}
function GetRandRow($sql, $arr= false) {
$rezarr = $this->GetAll($sql, $arr);
$sz = sizeof($rezarr);
return $rezarr[abs(rand()) % $sz];
}
/**
* Return one row of sql statement. Recordset is disposed for you.
* Note that SelectLimit should not be called.
*
* @param sql SQL statement
* @param [inputarr] input bind array
*/
function GetRow($sql,$inputarr=false) {
global $ADODB_COUNTRECS;
$crecs = $ADODB_COUNTRECS;
$ADODB_COUNTRECS = false;
$rs = $this->Execute($sql,$inputarr);
$ADODB_COUNTRECS = $crecs;
if ($rs) {
if (!$rs->EOF) {
$arr = $rs->fields;
} else {
$arr = array();
}
$rs->Close();
return $arr;
}
return false;
}
function CacheGetRow($secs2cache,$sql=false,$inputarr=false) {
$rs = $this->CacheExecute($secs2cache,$sql,$inputarr);
if ($rs) {
if (!$rs->EOF) {
$arr = $rs->fields;
} else {
$arr = array();
}
$rs->Close();
return $arr;
}
return false;
}
/**
* Insert or replace a single record. Note: this is not the same as MySQL's replace.
* ADOdb's Replace() uses update-insert semantics, not insert-delete-duplicates of MySQL.
* Also note that no table locking is done currently, so it is possible that the
* record be inserted twice by two programs...
*
* $this->Replace('products', array('prodname' =>"'Nails'","price" => 3.99), 'prodname');
*
* $table table name
* $fieldArray associative array of data (you must quote strings yourself).
* $keyCol the primary key field name or if compound key, array of field names
* autoQuote set to true to use a hueristic to quote strings. Works with nulls and numbers
* but does not work with dates nor SQL functions.
* has_autoinc the primary key is an auto-inc field, so skip in insert.
*
* Currently blob replace not supported
*
* returns 0 = fail, 1 = update, 2 = insert
*/
function Replace($table, $fieldArray, $keyCol, $autoQuote=false, $has_autoinc=false) {
global $ADODB_INCLUDED_LIB;
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
return _adodb_replace($this, $table, $fieldArray, $keyCol, $autoQuote, $has_autoinc);
}
/**
* Will select, getting rows from $offset (1-based), for $nrows.
* This simulates the MySQL "select * from table limit $offset,$nrows" , and
* the PostgreSQL "select * from table limit $nrows offset $offset". Note that
* MySQL and PostgreSQL parameter ordering is the opposite of the other.
* eg.
* CacheSelectLimit(15,'select * from table',3); will return rows 1 to 3 (1-based)
* CacheSelectLimit(15,'select * from table',3,2); will return rows 3 to 5 (1-based)
*
* BUG: Currently CacheSelectLimit fails with $sql with LIMIT or TOP clause already set
*
* @param [secs2cache] seconds to cache data, set to 0 to force query. This is optional
* @param sql
* @param [offset] is the row to start calculations from (1-based)
* @param [nrows] is the number of rows to get
* @param [inputarr] array of bind variables
* @return the recordset ($rs->databaseType == 'array')
*/
function CacheSelectLimit($secs2cache,$sql,$nrows=-1,$offset=-1,$inputarr=false) {
if (!is_numeric($secs2cache)) {
if ($sql === false) {
$sql = -1;
}
if ($offset == -1) {
$offset = false;
}
// sql, nrows, offset,inputarr
$rs = $this->SelectLimit($secs2cache,$sql,$nrows,$offset,$this->cacheSecs);
} else {
if ($sql === false) {
$this->outp_throw("Warning: \$sql missing from CacheSelectLimit()",'CacheSelectLimit');
}
$rs = $this->SelectLimit($sql,$nrows,$offset,$inputarr,$secs2cache);
}
return $rs;
}
/**
* Flush cached recordsets that match a particular $sql statement.
* If $sql == false, then we purge all files in the cache.
*/
function CacheFlush($sql=false,$inputarr=false) {
global $ADODB_CACHE_DIR, $ADODB_CACHE;
# Create cache if it does not exist
if (empty($ADODB_CACHE)) {
$this->_CreateCache();
}
if (!$sql) {
$ADODB_CACHE->flushall($this->debug);
return;
}
$f = $this->_gencachename($sql.serialize($inputarr),false);
return $ADODB_CACHE->flushcache($f, $this->debug);
}
/**
* Private function to generate filename for caching.
* Filename is generated based on:
*
* - sql statement
* - database type (oci8, ibase, ifx, etc)
* - database name
* - userid
* - setFetchMode (adodb 4.23)
*
* When not in safe mode, we create 256 sub-directories in the cache directory ($ADODB_CACHE_DIR).
* Assuming that we can have 50,000 files per directory with good performance,
* then we can scale to 12.8 million unique cached recordsets. Wow!
*/
function _gencachename($sql,$createdir) {
global $ADODB_CACHE, $ADODB_CACHE_DIR;
if ($this->fetchMode === false) {
global $ADODB_FETCH_MODE;
$mode = $ADODB_FETCH_MODE;
} else {
$mode = $this->fetchMode;
}
$m = md5($sql.$this->databaseType.$this->database.$this->user.$mode);
if (!$ADODB_CACHE->createdir) {
return $m;
}
if (!$createdir) {
$dir = $ADODB_CACHE->getdirname($m);
} else {
$dir = $ADODB_CACHE->createdir($m, $this->debug);
}
return $dir.'/adodb_'.$m.'.cache';
}
/**
* Execute SQL, caching recordsets.
*
* @param [secs2cache] seconds to cache data, set to 0 to force query.
* This is an optional parameter.
* @param sql SQL statement to execute
* @param [inputarr] holds the input data to bind to
* @return RecordSet or false
*/
function CacheExecute($secs2cache,$sql=false,$inputarr=false) {
global $ADODB_CACHE;
if (empty($ADODB_CACHE)) {
$this->_CreateCache();
}
if (!is_numeric($secs2cache)) {
$inputarr = $sql;
$sql = $secs2cache;
$secs2cache = $this->cacheSecs;
}
if (is_array($sql)) {
$sqlparam = $sql;
$sql = $sql[0];
} else
$sqlparam = $sql;
$md5file = $this->_gencachename($sql.serialize($inputarr),true);
$err = '';
if ($secs2cache > 0){
$rs = $ADODB_CACHE->readcache($md5file,$err,$secs2cache,$this->arrayClass);
$this->numCacheHits += 1;
} else {
$err='Timeout 1';
$rs = false;
$this->numCacheMisses += 1;
}
if (!$rs) {
// no cached rs found
if ($this->debug) {
if (get_magic_quotes_runtime() && !$this->memCache) {
ADOConnection::outp("Please disable magic_quotes_runtime - it corrupts cache files :(");
}
if ($this->debug !== -1) {
ADOConnection::outp( " $md5file cache failure: $err (this is a notice and not an error)");
}
}
$rs = $this->Execute($sqlparam,$inputarr);
if ($rs) {
$eof = $rs->EOF;
$rs = $this->_rs2rs($rs); // read entire recordset into memory immediately
$rs->timeCreated = time(); // used by caching
$txt = _rs2serialize($rs,false,$sql); // serialize
$ok = $ADODB_CACHE->writecache($md5file,$txt,$this->debug, $secs2cache);
if (!$ok) {
if ($ok === false) {
$em = 'Cache write error';
$en = -32000;
if ($fn = $this->raiseErrorFn) {
$fn($this->databaseType,'CacheExecute', $en, $em, $md5file,$sql,$this);
}
} else {
$em = 'Cache file locked warning';
$en = -32001;
// do not call error handling for just a warning
}
if ($this->debug) {
ADOConnection::outp( " ".$em);
}
}
if ($rs->EOF && !$eof) {
$rs->MoveFirst();
//$rs = csv2rs($md5file,$err);
$rs->connection = $this; // Pablo suggestion
}
} else if (!$this->memCache) {
$ADODB_CACHE->flushcache($md5file);
}
} else {
$this->_errorMsg = '';
$this->_errorCode = 0;
if ($this->fnCacheExecute) {
$fn = $this->fnCacheExecute;
$fn($this, $secs2cache, $sql, $inputarr);
}
// ok, set cached object found
$rs->connection = $this; // Pablo suggestion
if ($this->debug){
if ($this->debug == 99) {
adodb_backtrace();
}
$inBrowser = isset($_SERVER['HTTP_USER_AGENT']);
$ttl = $rs->timeCreated + $secs2cache - time();
$s = is_array($sql) ? $sql[0] : $sql;
if ($inBrowser) {
$s = ''.htmlspecialchars($s).'';
}
ADOConnection::outp( " $md5file reloaded, ttl=$ttl [ $s ]");
}
}
return $rs;
}
/*
Similar to PEAR DB's autoExecute(), except that
$mode can be 'INSERT' or 'UPDATE' or DB_AUTOQUERY_INSERT or DB_AUTOQUERY_UPDATE
If $mode == 'UPDATE', then $where is compulsory as a safety measure.
$forceUpdate means that even if the data has not changed, perform update.
*/
function AutoExecute($table, $fields_values, $mode = 'INSERT', $where = false, $forceUpdate = true, $magicq = false) {
if ($where === false && ($mode == 'UPDATE' || $mode == 2 /* DB_AUTOQUERY_UPDATE */) ) {
$this->outp_throw('AutoExecute: Illegal mode=UPDATE with empty WHERE clause', 'AutoExecute');
return false;
}
$sql = "SELECT * FROM $table";
$rs = $this->SelectLimit($sql, 1);
if (!$rs) {
return false; // table does not exist
}
$rs->tableName = $table;
if ($where !== false) {
$sql .= " WHERE $where";
}
$rs->sql = $sql;
switch($mode) {
case 'UPDATE':
case DB_AUTOQUERY_UPDATE:
$sql = $this->GetUpdateSQL($rs, $fields_values, $forceUpdate, $magicq);
break;
case 'INSERT':
case DB_AUTOQUERY_INSERT:
$sql = $this->GetInsertSQL($rs, $fields_values, $magicq);
break;
default:
$this->outp_throw("AutoExecute: Unknown mode=$mode", 'AutoExecute');
return false;
}
return $sql && $this->Execute($sql);
}
/**
* Generates an Update Query based on an existing recordset.
* $arrFields is an associative array of fields with the value
* that should be assigned.
*
* Note: This function should only be used on a recordset
* that is run against a single table and sql should only
* be a simple select stmt with no groupby/orderby/limit
*
* "Jonathan Younger"
*/
function GetUpdateSQL(&$rs, $arrFields,$forceUpdate=false,$magicq=false,$force=null) {
global $ADODB_INCLUDED_LIB;
// ********************************************************
// This is here to maintain compatibility
// with older adodb versions. Sets force type to force nulls if $forcenulls is set.
if (!isset($force)) {
global $ADODB_FORCE_TYPE;
$force = $ADODB_FORCE_TYPE;
}
// ********************************************************
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
return _adodb_getupdatesql($this,$rs,$arrFields,$forceUpdate,$magicq,$force);
}
/**
* Generates an Insert Query based on an existing recordset.
* $arrFields is an associative array of fields with the value
* that should be assigned.
*
* Note: This function should only be used on a recordset
* that is run against a single table.
*/
function GetInsertSQL(&$rs, $arrFields,$magicq=false,$force=null) {
global $ADODB_INCLUDED_LIB;
if (!isset($force)) {
global $ADODB_FORCE_TYPE;
$force = $ADODB_FORCE_TYPE;
}
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
return _adodb_getinsertsql($this,$rs,$arrFields,$magicq,$force);
}
/**
* Update a blob column, given a where clause. There are more sophisticated
* blob handling functions that we could have implemented, but all require
* a very complex API. Instead we have chosen something that is extremely
* simple to understand and use.
*
* Note: $blobtype supports 'BLOB' and 'CLOB', default is BLOB of course.
*
* Usage to update a $blobvalue which has a primary key blob_id=1 into a
* field blobtable.blobcolumn:
*
* UpdateBlob('blobtable', 'blobcolumn', $blobvalue, 'blob_id=1');
*
* Insert example:
*
* $conn->Execute('INSERT INTO blobtable (id, blobcol) VALUES (1, null)');
* $conn->UpdateBlob('blobtable','blobcol',$blob,'id=1');
*/
function UpdateBlob($table,$column,$val,$where,$blobtype='BLOB') {
return $this->Execute("UPDATE $table SET $column=? WHERE $where",array($val)) != false;
}
/**
* Usage:
* UpdateBlob('TABLE', 'COLUMN', '/path/to/file', 'ID=1');
*
* $blobtype supports 'BLOB' and 'CLOB'
*
* $conn->Execute('INSERT INTO blobtable (id, blobcol) VALUES (1, null)');
* $conn->UpdateBlob('blobtable','blobcol',$blobpath,'id=1');
*/
function UpdateBlobFile($table,$column,$path,$where,$blobtype='BLOB') {
$fd = fopen($path,'rb');
if ($fd === false) {
return false;
}
$val = fread($fd,filesize($path));
fclose($fd);
return $this->UpdateBlob($table,$column,$val,$where,$blobtype);
}
function BlobDecode($blob) {
return $blob;
}
function BlobEncode($blob) {
return $blob;
}
function GetCharSet() {
return $this->charSet;
}
function SetCharSet($charset) {
$this->charSet = $charset;
return true;
}
function IfNull( $field, $ifNull ) {
return " CASE WHEN $field is null THEN $ifNull ELSE $field END ";
}
function LogSQL($enable=true) {
include_once(ADODB_DIR.'/adodb-perf.inc.php');
if ($enable) {
$this->fnExecute = 'adodb_log_sql';
} else {
$this->fnExecute = false;
}
$old = $this->_logsql;
$this->_logsql = $enable;
if ($enable && !$old) {
$this->_affected = false;
}
return $old;
}
/**
* Usage:
* UpdateClob('TABLE', 'COLUMN', $var, 'ID=1', 'CLOB');
*
* $conn->Execute('INSERT INTO clobtable (id, clobcol) VALUES (1, null)');
* $conn->UpdateClob('clobtable','clobcol',$clob,'id=1');
*/
function UpdateClob($table,$column,$val,$where) {
return $this->UpdateBlob($table,$column,$val,$where,'CLOB');
}
// not the fastest implementation - quick and dirty - jlim
// for best performance, use the actual $rs->MetaType().
function MetaType($t,$len=-1,$fieldobj=false) {
if (empty($this->_metars)) {
$rsclass = $this->rsPrefix.$this->databaseType;
$this->_metars = new $rsclass(false,$this->fetchMode);
$this->_metars->connection = $this;
}
return $this->_metars->MetaType($t,$len,$fieldobj);
}
/**
* Change the SQL connection locale to a specified locale.
* This is used to get the date formats written depending on the client locale.
*/
function SetDateLocale($locale = 'En') {
$this->locale = $locale;
switch (strtoupper($locale))
{
case 'EN':
$this->fmtDate="'Y-m-d'";
$this->fmtTimeStamp = "'Y-m-d H:i:s'";
break;
case 'US':
$this->fmtDate = "'m-d-Y'";
$this->fmtTimeStamp = "'m-d-Y H:i:s'";
break;
case 'PT_BR':
case 'NL':
case 'FR':
case 'RO':
case 'IT':
$this->fmtDate="'d-m-Y'";
$this->fmtTimeStamp = "'d-m-Y H:i:s'";
break;
case 'GE':
$this->fmtDate="'d.m.Y'";
$this->fmtTimeStamp = "'d.m.Y H:i:s'";
break;
default:
$this->fmtDate="'Y-m-d'";
$this->fmtTimeStamp = "'Y-m-d H:i:s'";
break;
}
}
/**
* GetActiveRecordsClass Performs an 'ALL' query
*
* @param mixed $class This string represents the class of the current active record
* @param mixed $table Table used by the active record object
* @param mixed $whereOrderBy Where, order, by clauses
* @param mixed $bindarr
* @param mixed $primkeyArr
* @param array $extra Query extras: limit, offset...
* @param mixed $relations Associative array: table's foreign name, "hasMany", "belongsTo"
* @access public
* @return void
*/
function GetActiveRecordsClass(
$class, $table,$whereOrderBy=false,$bindarr=false, $primkeyArr=false,
$extra=array(),
$relations=array())
{
global $_ADODB_ACTIVE_DBS;
## reduce overhead of adodb.inc.php -- moved to adodb-active-record.inc.php
## if adodb-active-recordx is loaded -- should be no issue as they will probably use Find()
if (!isset($_ADODB_ACTIVE_DBS)) {
include_once(ADODB_DIR.'/adodb-active-record.inc.php');
}
return adodb_GetActiveRecordsClass($this, $class, $table, $whereOrderBy, $bindarr, $primkeyArr, $extra, $relations);
}
function GetActiveRecords($table,$where=false,$bindarr=false,$primkeyArr=false) {
$arr = $this->GetActiveRecordsClass('ADODB_Active_Record', $table, $where, $bindarr, $primkeyArr);
return $arr;
}
/**
* Close Connection
*/
function Close() {
$rez = $this->_close();
$this->_queryID = false;
$this->_connectionID = false;
return $rez;
}
/**
* Begin a Transaction. Must be followed by CommitTrans() or RollbackTrans().
*
* @return true if succeeded or false if database does not support transactions
*/
function BeginTrans() {
if ($this->debug) {
ADOConnection::outp("BeginTrans: Transactions not supported for this driver");
}
return false;
}
/* set transaction mode */
function SetTransactionMode( $transaction_mode ) {
$transaction_mode = $this->MetaTransaction($transaction_mode, $this->dataProvider);
$this->_transmode = $transaction_mode;
}
/*
http://msdn2.microsoft.com/en-US/ms173763.aspx
http://dev.mysql.com/doc/refman/5.0/en/innodb-transaction-isolation.html
http://www.postgresql.org/docs/8.1/interactive/sql-set-transaction.html
http://www.stanford.edu/dept/itss/docs/oracle/10g/server.101/b10759/statements_10005.htm
*/
function MetaTransaction($mode,$db) {
$mode = strtoupper($mode);
$mode = str_replace('ISOLATION LEVEL ','',$mode);
switch($mode) {
case 'READ UNCOMMITTED':
switch($db) {
case 'oci8':
case 'oracle':
return 'ISOLATION LEVEL READ COMMITTED';
default:
return 'ISOLATION LEVEL READ UNCOMMITTED';
}
break;
case 'READ COMMITTED':
return 'ISOLATION LEVEL READ COMMITTED';
break;
case 'REPEATABLE READ':
switch($db) {
case 'oci8':
case 'oracle':
return 'ISOLATION LEVEL SERIALIZABLE';
default:
return 'ISOLATION LEVEL REPEATABLE READ';
}
break;
case 'SERIALIZABLE':
return 'ISOLATION LEVEL SERIALIZABLE';
break;
default:
return $mode;
}
}
/**
* If database does not support transactions, always return true as data always commited
*
* @param $ok set to false to rollback transaction, true to commit
*
* @return true/false.
*/
function CommitTrans($ok=true) {
return true;
}
/**
* If database does not support transactions, rollbacks always fail, so return false
*
* @return true/false.
*/
function RollbackTrans() {
return false;
}
/**
* return the databases that the driver can connect to.
* Some databases will return an empty array.
*
* @return an array of database names.
*/
function MetaDatabases() {
global $ADODB_FETCH_MODE;
if ($this->metaDatabasesSQL) {
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->fetchMode !== false) {
$savem = $this->SetFetchMode(false);
}
$arr = $this->GetCol($this->metaDatabasesSQL);
if (isset($savem)) {
$this->SetFetchMode($savem);
}
$ADODB_FETCH_MODE = $save;
return $arr;
}
return false;
}
/**
* List procedures or functions in an array.
* @param procedureNamePattern a procedure name pattern; must match the procedure name as it is stored in the database
* @param catalog a catalog name; must match the catalog name as it is stored in the database;
* @param schemaPattern a schema name pattern;
*
* @return array of procedures on current database.
*
* Array(
* [name_of_procedure] => Array(
* [type] => PROCEDURE or FUNCTION
* [catalog] => Catalog_name
* [schema] => Schema_name
* [remarks] => explanatory comment on the procedure
* )
* )
*/
function MetaProcedures($procedureNamePattern = null, $catalog = null, $schemaPattern = null) {
return false;
}
/**
* @param ttype can either be 'VIEW' or 'TABLE' or false.
* If false, both views and tables are returned.
* "VIEW" returns only views
* "TABLE" returns only tables
* @param showSchema returns the schema/user with the table name, eg. USER.TABLE
* @param mask is the input mask - only supported by oci8 and postgresql
*
* @return array of tables for current database.
*/
function MetaTables($ttype=false,$showSchema=false,$mask=false) {
global $ADODB_FETCH_MODE;
if ($mask) {
return false;
}
if ($this->metaTablesSQL) {
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->fetchMode !== false) {
$savem = $this->SetFetchMode(false);
}
$rs = $this->Execute($this->metaTablesSQL);
if (isset($savem)) {
$this->SetFetchMode($savem);
}
$ADODB_FETCH_MODE = $save;
if ($rs === false) {
return false;
}
$arr = $rs->GetArray();
$arr2 = array();
if ($hast = ($ttype && isset($arr[0][1]))) {
$showt = strncmp($ttype,'T',1);
}
for ($i=0; $i < sizeof($arr); $i++) {
if ($hast) {
if ($showt == 0) {
if (strncmp($arr[$i][1],'T',1) == 0) {
$arr2[] = trim($arr[$i][0]);
}
} else {
if (strncmp($arr[$i][1],'V',1) == 0) {
$arr2[] = trim($arr[$i][0]);
}
}
} else
$arr2[] = trim($arr[$i][0]);
}
$rs->Close();
return $arr2;
}
return false;
}
function _findschema(&$table,&$schema) {
if (!$schema && ($at = strpos($table,'.')) !== false) {
$schema = substr($table,0,$at);
$table = substr($table,$at+1);
}
}
/**
* List columns in a database as an array of ADOFieldObjects.
* See top of file for definition of object.
*
* @param $table table name to query
* @param $normalize makes table name case-insensitive (required by some databases)
* @schema is optional database schema to use - not supported by all databases.
*
* @return array of ADOFieldObjects for current table.
*/
function MetaColumns($table,$normalize=true) {
global $ADODB_FETCH_MODE;
if (!empty($this->metaColumnsSQL)) {
$schema = false;
$this->_findschema($table,$schema);
$save = $ADODB_FETCH_MODE;
$ADODB_FETCH_MODE = ADODB_FETCH_NUM;
if ($this->fetchMode !== false) {
$savem = $this->SetFetchMode(false);
}
$rs = $this->Execute(sprintf($this->metaColumnsSQL,($normalize)?strtoupper($table):$table));
if (isset($savem)) {
$this->SetFetchMode($savem);
}
$ADODB_FETCH_MODE = $save;
if ($rs === false || $rs->EOF) {
return false;
}
$retarr = array();
while (!$rs->EOF) { //print_r($rs->fields);
$fld = new ADOFieldObject();
$fld->name = $rs->fields[0];
$fld->type = $rs->fields[1];
if (isset($rs->fields[3]) && $rs->fields[3]) {
if ($rs->fields[3]>0) {
$fld->max_length = $rs->fields[3];
}
$fld->scale = $rs->fields[4];
if ($fld->scale>0) {
$fld->max_length += 1;
}
} else {
$fld->max_length = $rs->fields[2];
}
if ($ADODB_FETCH_MODE == ADODB_FETCH_NUM) {
$retarr[] = $fld;
} else {
$retarr[strtoupper($fld->name)] = $fld;
}
$rs->MoveNext();
}
$rs->Close();
return $retarr;
}
return false;
}
/**
* List indexes on a table as an array.
* @param table table name to query
* @param primary true to only show primary keys. Not actually used for most databases
*
* @return array of indexes on current table. Each element represents an index, and is itself an associative array.
*
* Array(
* [name_of_index] => Array(
* [unique] => true or false
* [columns] => Array(
* [0] => firstname
* [1] => lastname
* )
* )
* )
*/
function MetaIndexes($table, $primary = false, $owner = false) {
return false;
}
/**
* List columns names in a table as an array.
* @param table table name to query
*
* @return array of column names for current table.
*/
function MetaColumnNames($table, $numIndexes=false,$useattnum=false /* only for postgres */) {
$objarr = $this->MetaColumns($table);
if (!is_array($objarr)) {
return false;
}
$arr = array();
if ($numIndexes) {
$i = 0;
if ($useattnum) {
foreach($objarr as $v)
$arr[$v->attnum] = $v->name;
} else
foreach($objarr as $v) $arr[$i++] = $v->name;
} else
foreach($objarr as $v) $arr[strtoupper($v->name)] = $v->name;
return $arr;
}
/**
* Different SQL databases used different methods to combine strings together.
* This function provides a wrapper.
*
* param s variable number of string parameters
*
* Usage: $db->Concat($str1,$str2);
*
* @return concatenated string
*/
function Concat() {
$arr = func_get_args();
return implode($this->concat_operator, $arr);
}
/**
* Converts a date "d" to a string that the database can understand.
*
* @param d a date in Unix date time format.
*
* @return date string in database date format
*/
function DBDate($d, $isfld=false) {
if (empty($d) && $d !== 0) {
return 'null';
}
if ($isfld) {
return $d;
}
if (is_object($d)) {
return $d->format($this->fmtDate);
}
if (is_string($d) && !is_numeric($d)) {
if ($d === 'null') {
return $d;
}
if (strncmp($d,"'",1) === 0) {
$d = _adodb_safedateq($d);
return $d;
}
if ($this->isoDates) {
return "'$d'";
}
$d = ADOConnection::UnixDate($d);
}
return adodb_date($this->fmtDate,$d);
}
function BindDate($d) {
$d = $this->DBDate($d);
if (strncmp($d,"'",1)) {
return $d;
}
return substr($d,1,strlen($d)-2);
}
function BindTimeStamp($d) {
$d = $this->DBTimeStamp($d);
if (strncmp($d,"'",1)) {
return $d;
}
return substr($d,1,strlen($d)-2);
}
/**
* Converts a timestamp "ts" to a string that the database can understand.
*
* @param ts a timestamp in Unix date time format.
*
* @return timestamp string in database timestamp format
*/
function DBTimeStamp($ts,$isfld=false) {
if (empty($ts) && $ts !== 0) {
return 'null';
}
if ($isfld) {
return $ts;
}
if (is_object($ts)) {
return $ts->format($this->fmtTimeStamp);
}
# strlen(14) allows YYYYMMDDHHMMSS format
if (!is_string($ts) || (is_numeric($ts) && strlen($ts)<14)) {
return adodb_date($this->fmtTimeStamp,$ts);
}
if ($ts === 'null') {
return $ts;
}
if ($this->isoDates && strlen($ts) !== 14) {
$ts = _adodb_safedate($ts);
return "'$ts'";
}
$ts = ADOConnection::UnixTimeStamp($ts);
return adodb_date($this->fmtTimeStamp,$ts);
}
/**
* Also in ADORecordSet.
* @param $v is a date string in YYYY-MM-DD format
*
* @return date in unix timestamp format, or 0 if before TIMESTAMP_FIRST_YEAR, or false if invalid date format
*/
static function UnixDate($v) {
if (is_object($v)) {
// odbtp support
//( [year] => 2004 [month] => 9 [day] => 4 [hour] => 12 [minute] => 44 [second] => 8 [fraction] => 0 )
return adodb_mktime($v->hour,$v->minute,$v->second,$v->month,$v->day, $v->year);
}
if (is_numeric($v) && strlen($v) !== 8) {
return $v;
}
if (!preg_match( "|^([0-9]{4})[-/\.]?([0-9]{1,2})[-/\.]?([0-9]{1,2})|", $v, $rr)) {
return false;
}
if ($rr[1] <= TIMESTAMP_FIRST_YEAR) {
return 0;
}
// h-m-s-MM-DD-YY
return @adodb_mktime(0,0,0,$rr[2],$rr[3],$rr[1]);
}
/**
* Also in ADORecordSet.
* @param $v is a timestamp string in YYYY-MM-DD HH-NN-SS format
*
* @return date in unix timestamp format, or 0 if before TIMESTAMP_FIRST_YEAR, or false if invalid date format
*/
static function UnixTimeStamp($v) {
if (is_object($v)) {
// odbtp support
//( [year] => 2004 [month] => 9 [day] => 4 [hour] => 12 [minute] => 44 [second] => 8 [fraction] => 0 )
return adodb_mktime($v->hour,$v->minute,$v->second,$v->month,$v->day, $v->year);
}
if (!preg_match(
"|^([0-9]{4})[-/\.]?([0-9]{1,2})[-/\.]?([0-9]{1,2})[ ,-]*(([0-9]{1,2}):?([0-9]{1,2}):?([0-9\.]{1,4}))?|",
($v), $rr)) return false;
if ($rr[1] <= TIMESTAMP_FIRST_YEAR && $rr[2]<= 1) {
return 0;
}
// h-m-s-MM-DD-YY
if (!isset($rr[5])) {
return adodb_mktime(0,0,0,$rr[2],$rr[3],$rr[1]);
}
return @adodb_mktime($rr[5],$rr[6],$rr[7],$rr[2],$rr[3],$rr[1]);
}
/**
* Also in ADORecordSet.
*
* Format database date based on user defined format.
*
* @param v is the character date in YYYY-MM-DD format, returned by database
* @param fmt is the format to apply to it, using date()
*
* @return a date formated as user desires
*/
function UserDate($v,$fmt='Y-m-d',$gmt=false) {
$tt = $this->UnixDate($v);
// $tt == -1 if pre TIMESTAMP_FIRST_YEAR
if (($tt === false || $tt == -1) && $v != false) {
return $v;
} else if ($tt == 0) {
return $this->emptyDate;
} else if ($tt == -1) {
// pre-TIMESTAMP_FIRST_YEAR
}
return ($gmt) ? adodb_gmdate($fmt,$tt) : adodb_date($fmt,$tt);
}
/**
*
* @param v is the character timestamp in YYYY-MM-DD hh:mm:ss format
* @param fmt is the format to apply to it, using date()
*
* @return a timestamp formated as user desires
*/
function UserTimeStamp($v,$fmt='Y-m-d H:i:s',$gmt=false) {
if (!isset($v)) {
return $this->emptyTimeStamp;
}
# strlen(14) allows YYYYMMDDHHMMSS format
if (is_numeric($v) && strlen($v)<14) {
return ($gmt) ? adodb_gmdate($fmt,$v) : adodb_date($fmt,$v);
}
$tt = $this->UnixTimeStamp($v);
// $tt == -1 if pre TIMESTAMP_FIRST_YEAR
if (($tt === false || $tt == -1) && $v != false) {
return $v;
}
if ($tt == 0) {
return $this->emptyTimeStamp;
}
return ($gmt) ? adodb_gmdate($fmt,$tt) : adodb_date($fmt,$tt);
}
function escape($s,$magic_quotes=false) {
return $this->addq($s,$magic_quotes);
}
/**
* Quotes a string, without prefixing nor appending quotes.
*/
function addq($s,$magic_quotes=false) {
if (!$magic_quotes) {
if ($this->replaceQuote[0] == '\\') {
// only since php 4.0.5
$s = adodb_str_replace(array('\\',"\0"),array('\\\\',"\\\0"),$s);
//$s = str_replace("\0","\\\0", str_replace('\\','\\\\',$s));
}
return str_replace("'",$this->replaceQuote,$s);
}
// undo magic quotes for "
$s = str_replace('\\"','"',$s);
if ($this->replaceQuote == "\\'" || ini_get('magic_quotes_sybase')) {
// ' already quoted, no need to change anything
return $s;
} else {
// change \' to '' for sybase/mssql
$s = str_replace('\\\\','\\',$s);
return str_replace("\\'",$this->replaceQuote,$s);
}
}
/**
* Correctly quotes a string so that all strings are escaped. We prefix and append
* to the string single-quotes.
* An example is $db->qstr("Don't bother",magic_quotes_runtime());
*
* @param s the string to quote
* @param [magic_quotes] if $s is GET/POST var, set to get_magic_quotes_gpc().
* This undoes the stupidity of magic quotes for GPC.
*
* @return quoted string to be sent back to database
*/
function qstr($s,$magic_quotes=false) {
if (!$magic_quotes) {
if ($this->replaceQuote[0] == '\\'){
// only since php 4.0.5
$s = adodb_str_replace(array('\\',"\0"),array('\\\\',"\\\0"),$s);
//$s = str_replace("\0","\\\0", str_replace('\\','\\\\',$s));
}
return "'".str_replace("'",$this->replaceQuote,$s)."'";
}
// undo magic quotes for "
$s = str_replace('\\"','"',$s);
if ($this->replaceQuote == "\\'" || ini_get('magic_quotes_sybase')) {
// ' already quoted, no need to change anything
return "'$s'";
} else {
// change \' to '' for sybase/mssql
$s = str_replace('\\\\','\\',$s);
return "'".str_replace("\\'",$this->replaceQuote,$s)."'";
}
}
/**
* Will select the supplied $page number from a recordset, given that it is paginated in pages of
* $nrows rows per page. It also saves two boolean values saying if the given page is the first
* and/or last one of the recordset. Added by Iván Oliva to provide recordset pagination.
*
* See docs-adodb.htm#ex8 for an example of usage.
*
* @param sql
* @param nrows is the number of rows per page to get
* @param page is the page number to get (1-based)
* @param [inputarr] array of bind variables
* @param [secs2cache] is a private parameter only used by jlim
* @return the recordset ($rs->databaseType == 'array')
*
* NOTE: phpLens uses a different algorithm and does not use PageExecute().
*
*/
function PageExecute($sql, $nrows, $page, $inputarr=false, $secs2cache=0) {
global $ADODB_INCLUDED_LIB;
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
if ($this->pageExecuteCountRows) {
$rs = _adodb_pageexecute_all_rows($this, $sql, $nrows, $page, $inputarr, $secs2cache);
} else {
$rs = _adodb_pageexecute_no_last_page($this, $sql, $nrows, $page, $inputarr, $secs2cache);
}
return $rs;
}
/**
* Will select the supplied $page number from a recordset, given that it is paginated in pages of
* $nrows rows per page. It also saves two boolean values saying if the given page is the first
* and/or last one of the recordset. Added by Iván Oliva to provide recordset pagination.
*
* @param secs2cache seconds to cache data, set to 0 to force query
* @param sql
* @param nrows is the number of rows per page to get
* @param page is the page number to get (1-based)
* @param [inputarr] array of bind variables
* @return the recordset ($rs->databaseType == 'array')
*/
function CachePageExecute($secs2cache, $sql, $nrows, $page,$inputarr=false) {
/*switch($this->dataProvider) {
case 'postgres':
case 'mysql':
break;
default: $secs2cache = 0; break;
}*/
$rs = $this->PageExecute($sql,$nrows,$page,$inputarr,$secs2cache);
return $rs;
}
/**
* Get the last error recorded by PHP and clear the message.
*
* By clearing the message, it becomes possible to detect whether a new error
* has occurred, even when it is the same error as before being repeated.
*
* @return array|null Array if an error has previously occurred. Null otherwise.
*/
protected function resetLastError() {
$error = error_get_last();
if (is_array($error)) {
$error['message'] = '';
}
return $error;
}
/**
* Compare a previously stored error message with the last error recorded by PHP
* to determine whether a new error has occured.
*
* @param array|null $old Optional. Previously stored return value of error_get_last().
*
* @return string The error message if a new error has occured
* or an empty string if no (new) errors have occured..
*/
protected function getChangedErrorMsg($old = null) {
$new = error_get_last();
if (is_null($new)) {
// No error has occured yet at all.
return '';
}
if (is_null($old)) {
// First error recorded.
return $new['message'];
}
$changed = false;
foreach($new as $key => $value) {
if ($new[$key] !== $old[$key]) {
$changed = true;
break;
}
}
if ($changed === true) {
return $new['message'];
}
return '';
}
} // end class ADOConnection
//==============================================================================================
// CLASS ADOFetchObj
//==============================================================================================
/**
* Internal placeholder for record objects. Used by ADORecordSet->FetchObj().
*/
class ADOFetchObj {
};
//==============================================================================================
// CLASS ADORecordSet_empty
//==============================================================================================
class ADODB_Iterator_empty implements Iterator {
private $rs;
function __construct($rs) {
$this->rs = $rs;
}
function rewind() {}
function valid() {
return !$this->rs->EOF;
}
function key() {
return false;
}
function current() {
return false;
}
function next() {}
function __call($func, $params) {
return call_user_func_array(array($this->rs, $func), $params);
}
function hasMore() {
return false;
}
}
/**
* Lightweight recordset when there are no records to be returned
*/
class ADORecordSet_empty implements IteratorAggregate
{
var $dataProvider = 'empty';
var $databaseType = false;
var $EOF = true;
var $_numOfRows = 0;
var $fields = false;
var $connection = false;
function RowCount() {
return 0;
}
function RecordCount() {
return 0;
}
function PO_RecordCount() {
return 0;
}
function Close() {
return true;
}
function FetchRow() {
return false;
}
function FieldCount() {
return 0;
}
function Init() {}
function getIterator() {
return new ADODB_Iterator_empty($this);
}
function GetAssoc() {
return array();
}
function GetArray() {
return array();
}
function GetAll() {
return array();
}
function GetArrayLimit() {
return array();
}
function GetRows() {
return array();
}
function GetRowAssoc() {
return array();
}
function MaxRecordCount() {
return 0;
}
function NumRows() {
return 0;
}
function NumCols() {
return 0;
}
}
//==============================================================================================
// DATE AND TIME FUNCTIONS
//==============================================================================================
if (!defined('ADODB_DATE_VERSION')) {
include(ADODB_DIR.'/adodb-time.inc.php');
}
//==============================================================================================
// CLASS ADORecordSet
//==============================================================================================
class ADODB_Iterator implements Iterator {
private $rs;
function __construct($rs) {
$this->rs = $rs;
}
function rewind() {
$this->rs->MoveFirst();
}
function valid() {
return !$this->rs->EOF;
}
function key() {
return $this->rs->_currentRow;
}
function current() {
return $this->rs->fields;
}
function next() {
$this->rs->MoveNext();
}
function __call($func, $params) {
return call_user_func_array(array($this->rs, $func), $params);
}
function hasMore() {
return !$this->rs->EOF;
}
}
/**
* RecordSet class that represents the dataset returned by the database.
* To keep memory overhead low, this class holds only the current row in memory.
* No prefetching of data is done, so the RecordCount() can return -1 ( which
* means recordcount not known).
*/
class ADORecordSet implements IteratorAggregate {
/**
* public variables
*/
var $dataProvider = "native";
var $fields = false; /// holds the current row data
var $blobSize = 100; /// any varchar/char field this size or greater is treated as a blob
/// in other words, we use a text area for editing.
var $canSeek = false; /// indicates that seek is supported
var $sql; /// sql text
var $EOF = false; /// Indicates that the current record position is after the last record in a Recordset object.
var $emptyTimeStamp = ' '; /// what to display when $time==0
var $emptyDate = ' '; /// what to display when $time==0
var $debug = false;
var $timeCreated=0; /// datetime in Unix format rs created -- for cached recordsets
var $bind = false; /// used by Fields() to hold array - should be private?
var $fetchMode; /// default fetch mode
var $connection = false; /// the parent connection
/**
* private variables
*/
var $_numOfRows = -1; /** number of rows, or -1 */
var $_numOfFields = -1; /** number of fields in recordset */
var $_queryID = -1; /** This variable keeps the result link identifier. */
var $_currentRow = -1; /** This variable keeps the current row in the Recordset. */
var $_closed = false; /** has recordset been closed */
var $_inited = false; /** Init() should only be called once */
var $_obj; /** Used by FetchObj */
var $_names; /** Used by FetchObj */
var $_currentPage = -1; /** Added by Iván Oliva to implement recordset pagination */
var $_atFirstPage = false; /** Added by Iván Oliva to implement recordset pagination */
var $_atLastPage = false; /** Added by Iván Oliva to implement recordset pagination */
var $_lastPageNo = -1;
var $_maxRecordCount = 0;
var $datetime = false;
/**
* Constructor
*
* @param queryID this is the queryID returned by ADOConnection->_query()
*
*/
function __construct($queryID) {
$this->_queryID = $queryID;
}
function __destruct() {
$this->Close();
}
function getIterator() {
return new ADODB_Iterator($this);
}
/* this is experimental - i don't really know what to return... */
function __toString() {
include_once(ADODB_DIR.'/toexport.inc.php');
return _adodb_export($this,',',',',false,true);
}
function Init() {
if ($this->_inited) {
return;
}
$this->_inited = true;
if ($this->_queryID) {
@$this->_initrs();
} else {
$this->_numOfRows = 0;
$this->_numOfFields = 0;
}
if ($this->_numOfRows != 0 && $this->_numOfFields && $this->_currentRow == -1) {
$this->_currentRow = 0;
if ($this->EOF = ($this->_fetch() === false)) {
$this->_numOfRows = 0; // _numOfRows could be -1
}
} else {
$this->EOF = true;
}
}
/**
* Generate a SELECT tag from a recordset, and return the HTML markup.
*
* If the recordset has 2 columns, we treat the first one as the text to
* display to the user, and the second as the return value. Extra columns
* are discarded.
*
* @param string $name Name of SELECT tag
* @param string|array $defstr The value to highlight. Use an array for multiple highlight values.
* @param bool|string $blank1stItem True to create an empty item (default), False not to add one;
* 'string' to set its label and 'value:string' to assign a value to it.
* @param bool $multiple True for multi-select list
* @param int $size Number of rows to show (applies to multi-select box only)
* @param string $selectAttr Additional attributes to defined for SELECT tag,
* useful for holding javascript onChange='...' handlers, CSS class, etc.
* @param bool $compareFirstCol When true (default), $defstr is compared against the value (column 2),
* while false will compare against the description (column 1).
*
* @return string HTML
*/
function getMenu($name, $defstr = '', $blank1stItem = true, $multiple = false,
$size = 0, $selectAttr = '', $compareFirstCol = true)
{
global $ADODB_INCLUDED_LIB;
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
return _adodb_getmenu($this, $name, $defstr, $blank1stItem, $multiple,
$size, $selectAttr, $compareFirstCol);
}
/**
* Generate a SELECT tag with groups from a recordset, and return the HTML markup.
*
* The recordset must have 3 columns and be ordered by the 3rd column. The
* first column contains the text to display to the user, the second is the
* return value and the third is the option group. Extra columns are discarded.
* Default strings are compared with the SECOND column.
*
* @param string $name Name of SELECT tag
* @param string|array $defstr The value to highlight. Use an array for multiple highlight values.
* @param bool|string $blank1stItem True to create an empty item (default), False not to add one;
* 'string' to set its label and 'value:string' to assign a value to it.
* @param bool $multiple True for multi-select list
* @param int $size Number of rows to show (applies to multi-select box only)
* @param string $selectAttr Additional attributes to defined for SELECT tag,
* useful for holding javascript onChange='...' handlers, CSS class, etc.
* @param bool $compareFirstCol When true (default), $defstr is compared against the value (column 2),
* while false will compare against the description (column 1).
*
* @return string HTML
*/
function getMenuGrouped($name, $defstr = '', $blank1stItem = true, $multiple = false,
$size = 0, $selectAttr = '', $compareFirstCol = true)
{
global $ADODB_INCLUDED_LIB;
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
return _adodb_getmenu_gp($this, $name, $defstr, $blank1stItem, $multiple,
$size, $selectAttr, $compareFirstCol);
}
/**
* Generate a SELECT tag from a recordset, and return the HTML markup.
*
* Same as GetMenu(), except that default strings are compared with the
* FIRST column (the description).
*
* @param string $name Name of SELECT tag
* @param string|array $defstr The value to highlight. Use an array for multiple highlight values.
* @param bool|string $blank1stItem True to create an empty item (default), False not to add one;
* 'string' to set its label and 'value:string' to assign a value to it.
* @param bool $multiple True for multi-select list
* @param int $size Number of rows to show (applies to multi-select box only)
* @param string $selectAttr Additional attributes to defined for SELECT tag,
* useful for holding javascript onChange='...' handlers, CSS class, etc.
*
* @return string HTML
*
* @deprecated 5.21.0 Use getMenu() with $compareFirstCol = false instead.
*/
function getMenu2($name, $defstr = '', $blank1stItem = true, $multiple = false,
$size = 0, $selectAttr = '')
{
return $this->getMenu($name, $defstr, $blank1stItem, $multiple,
$size, $selectAttr,false);
}
/**
* Generate a SELECT tag with groups from a recordset, and return the HTML markup.
*
* Same as GetMenuGrouped(), except that default strings are compared with the
* FIRST column (the description).
*
* @param string $name Name of SELECT tag
* @param string|array $defstr The value to highlight. Use an array for multiple highlight values.
* @param bool|string $blank1stItem True to create an empty item (default), False not to add one;
* 'string' to set its label and 'value:string' to assign a value to it.
* @param bool $multiple True for multi-select list
* @param int $size Number of rows to show (applies to multi-select box only)
* @param string $selectAttr Additional attributes to defined for SELECT tag,
* useful for holding javascript onChange='...' handlers, CSS class, etc.
*
* @return string HTML
*
* @deprecated 5.21.0 Use getMenuGrouped() with $compareFirstCol = false instead.
*/
function getMenu3($name, $defstr = '', $blank1stItem = true, $multiple = false,
$size = 0, $selectAttr = '')
{
return $this->getMenuGrouped($name, $defstr, $blank1stItem, $multiple,
$size, $selectAttr, false);
}
/**
* return recordset as a 2-dimensional array.
*
* @param [nRows] is the number of rows to return. -1 means every row.
*
* @return an array indexed by the rows (0-based) from the recordset
*/
function GetArray($nRows = -1) {
global $ADODB_EXTENSION; if ($ADODB_EXTENSION) {
$results = adodb_getall($this,$nRows);
return $results;
}
$results = array();
$cnt = 0;
while (!$this->EOF && $nRows != $cnt) {
$results[] = $this->fields;
$this->MoveNext();
$cnt++;
}
return $results;
}
function GetAll($nRows = -1) {
$arr = $this->GetArray($nRows);
return $arr;
}
/*
* Some databases allow multiple recordsets to be returned. This function
* will return true if there is a next recordset, or false if no more.
*/
function NextRecordSet() {
return false;
}
/**
* return recordset as a 2-dimensional array.
* Helper function for ADOConnection->SelectLimit()
*
* @param offset is the row to start calculations from (1-based)
* @param [nrows] is the number of rows to return
*
* @return an array indexed by the rows (0-based) from the recordset
*/
function GetArrayLimit($nrows,$offset=-1) {
if ($offset <= 0) {
$arr = $this->GetArray($nrows);
return $arr;
}
$this->Move($offset);
$results = array();
$cnt = 0;
while (!$this->EOF && $nrows != $cnt) {
$results[$cnt++] = $this->fields;
$this->MoveNext();
}
return $results;
}
/**
* Synonym for GetArray() for compatibility with ADO.
*
* @param [nRows] is the number of rows to return. -1 means every row.
*
* @return an array indexed by the rows (0-based) from the recordset
*/
function GetRows($nRows = -1) {
$arr = $this->GetArray($nRows);
return $arr;
}
/**
* return whole recordset as a 2-dimensional associative array if there are more than 2 columns.
* The first column is treated as the key and is not included in the array.
* If there is only 2 columns, it will return a 1 dimensional array of key-value pairs unless
* $force_array == true.
*
* @param [force_array] has only meaning if we have 2 data columns. If false, a 1 dimensional
* array is returned, otherwise a 2 dimensional array is returned. If this sounds confusing,
* read the source.
*
* @param [first2cols] means if there are more than 2 cols, ignore the remaining cols and
* instead of returning array[col0] => array(remaining cols), return array[col0] => col1
*
* @return an associative array indexed by the first column of the array,
* or false if the data has less than 2 cols.
*/
function GetAssoc($force_array = false, $first2cols = false) {
global $ADODB_EXTENSION;
$cols = $this->_numOfFields;
if ($cols < 2) {
return false;
}
// Empty recordset
if (!$this->fields) {
return array();
}
// Determine whether the array is associative or 0-based numeric
$numIndex = array_keys($this->fields) == range(0, count($this->fields) - 1);
$results = array();
if (!$first2cols && ($cols > 2 || $force_array)) {
if ($ADODB_EXTENSION) {
if ($numIndex) {
while (!$this->EOF) {
$results[trim($this->fields[0])] = array_slice($this->fields, 1);
adodb_movenext($this);
}
} else {
while (!$this->EOF) {
// Fix for array_slice re-numbering numeric associative keys
$keys = array_slice(array_keys($this->fields), 1);
$sliced_array = array();
foreach($keys as $key) {
$sliced_array[$key] = $this->fields[$key];
}
$results[trim(reset($this->fields))] = $sliced_array;
adodb_movenext($this);
}
}
} else {
if ($numIndex) {
while (!$this->EOF) {
$results[trim($this->fields[0])] = array_slice($this->fields, 1);
$this->MoveNext();
}
} else {
while (!$this->EOF) {
// Fix for array_slice re-numbering numeric associative keys
$keys = array_slice(array_keys($this->fields), 1);
$sliced_array = array();
foreach($keys as $key) {
$sliced_array[$key] = $this->fields[$key];
}
$results[trim(reset($this->fields))] = $sliced_array;
$this->MoveNext();
}
}
}
} else {
if ($ADODB_EXTENSION) {
// return scalar values
if ($numIndex) {
while (!$this->EOF) {
// some bug in mssql PHP 4.02 -- doesn't handle references properly so we FORCE creating a new string
$results[trim(($this->fields[0]))] = $this->fields[1];
adodb_movenext($this);
}
} else {
while (!$this->EOF) {
// some bug in mssql PHP 4.02 -- doesn't handle references properly so we FORCE creating a new string
$v1 = trim(reset($this->fields));
$v2 = ''.next($this->fields);
$results[$v1] = $v2;
adodb_movenext($this);
}
}
} else {
if ($numIndex) {
while (!$this->EOF) {
// some bug in mssql PHP 4.02 -- doesn't handle references properly so we FORCE creating a new string
$results[trim(($this->fields[0]))] = $this->fields[1];
$this->MoveNext();
}
} else {
while (!$this->EOF) {
// some bug in mssql PHP 4.02 -- doesn't handle references properly so we FORCE creating a new string
$v1 = trim(reset($this->fields));
$v2 = ''.next($this->fields);
$results[$v1] = $v2;
$this->MoveNext();
}
}
}
}
$ref = $results; # workaround accelerator incompat with PHP 4.4 :(
return $ref;
}
/**
*
* @param v is the character timestamp in YYYY-MM-DD hh:mm:ss format
* @param fmt is the format to apply to it, using date()
*
* @return a timestamp formated as user desires
*/
function UserTimeStamp($v,$fmt='Y-m-d H:i:s') {
if (is_numeric($v) && strlen($v)<14) {
return adodb_date($fmt,$v);
}
$tt = $this->UnixTimeStamp($v);
// $tt == -1 if pre TIMESTAMP_FIRST_YEAR
if (($tt === false || $tt == -1) && $v != false) {
return $v;
}
if ($tt === 0) {
return $this->emptyTimeStamp;
}
return adodb_date($fmt,$tt);
}
/**
* @param v is the character date in YYYY-MM-DD format, returned by database
* @param fmt is the format to apply to it, using date()
*
* @return a date formated as user desires
*/
function UserDate($v,$fmt='Y-m-d') {
$tt = $this->UnixDate($v);
// $tt == -1 if pre TIMESTAMP_FIRST_YEAR
if (($tt === false || $tt == -1) && $v != false) {
return $v;
} else if ($tt == 0) {
return $this->emptyDate;
} else if ($tt == -1) {
// pre-TIMESTAMP_FIRST_YEAR
}
return adodb_date($fmt,$tt);
}
/**
* @param $v is a date string in YYYY-MM-DD format
*
* @return date in unix timestamp format, or 0 if before TIMESTAMP_FIRST_YEAR, or false if invalid date format
*/
static function UnixDate($v) {
return ADOConnection::UnixDate($v);
}
/**
* @param $v is a timestamp string in YYYY-MM-DD HH-NN-SS format
*
* @return date in unix timestamp format, or 0 if before TIMESTAMP_FIRST_YEAR, or false if invalid date format
*/
static function UnixTimeStamp($v) {
return ADOConnection::UnixTimeStamp($v);
}
/**
* PEAR DB Compat - do not use internally
*/
function Free() {
return $this->Close();
}
/**
* PEAR DB compat, number of rows
*/
function NumRows() {
return $this->_numOfRows;
}
/**
* PEAR DB compat, number of cols
*/
function NumCols() {
return $this->_numOfFields;
}
/**
* Fetch a row, returning false if no more rows.
* This is PEAR DB compat mode.
*
* @return false or array containing the current record
*/
function FetchRow() {
if ($this->EOF) {
return false;
}
$arr = $this->fields;
$this->_currentRow++;
if (!$this->_fetch()) {
$this->EOF = true;
}
return $arr;
}
/**
* Fetch a row, returning PEAR_Error if no more rows.
* This is PEAR DB compat mode.
*
* @return DB_OK or error object
*/
function FetchInto(&$arr) {
if ($this->EOF) {
return (defined('PEAR_ERROR_RETURN')) ? new PEAR_Error('EOF',-1): false;
}
$arr = $this->fields;
$this->MoveNext();
return 1; // DB_OK
}
/**
* Move to the first row in the recordset. Many databases do NOT support this.
*
* @return true or false
*/
function MoveFirst() {
if ($this->_currentRow == 0) {
return true;
}
return $this->Move(0);
}
/**
* Move to the last row in the recordset.
*
* @return true or false
*/
function MoveLast() {
if ($this->_numOfRows >= 0) {
return $this->Move($this->_numOfRows-1);
}
if ($this->EOF) {
return false;
}
while (!$this->EOF) {
$f = $this->fields;
$this->MoveNext();
}
$this->fields = $f;
$this->EOF = false;
return true;
}
/**
* Move to next record in the recordset.
*
* @return true if there still rows available, or false if there are no more rows (EOF).
*/
function MoveNext() {
if (!$this->EOF) {
$this->_currentRow++;
if ($this->_fetch()) {
return true;
}
}
$this->EOF = true;
/* -- tested error handling when scrolling cursor -- seems useless.
$conn = $this->connection;
if ($conn && $conn->raiseErrorFn && ($errno = $conn->ErrorNo())) {
$fn = $conn->raiseErrorFn;
$fn($conn->databaseType,'MOVENEXT',$errno,$conn->ErrorMsg().' ('.$this->sql.')',$conn->host,$conn->database);
}
*/
return false;
}
/**
* Random access to a specific row in the recordset. Some databases do not support
* access to previous rows in the databases (no scrolling backwards).
*
* @param rowNumber is the row to move to (0-based)
*
* @return true if there still rows available, or false if there are no more rows (EOF).
*/
function Move($rowNumber = 0) {
$this->EOF = false;
if ($rowNumber == $this->_currentRow) {
return true;
}
if ($rowNumber >= $this->_numOfRows) {
if ($this->_numOfRows != -1) {
$rowNumber = $this->_numOfRows-2;
}
}
if ($rowNumber < 0) {
$this->EOF = true;
return false;
}
if ($this->canSeek) {
if ($this->_seek($rowNumber)) {
$this->_currentRow = $rowNumber;
if ($this->_fetch()) {
return true;
}
} else {
$this->EOF = true;
return false;
}
} else {
if ($rowNumber < $this->_currentRow) {
return false;
}
global $ADODB_EXTENSION;
if ($ADODB_EXTENSION) {
while (!$this->EOF && $this->_currentRow < $rowNumber) {
adodb_movenext($this);
}
} else {
while (! $this->EOF && $this->_currentRow < $rowNumber) {
$this->_currentRow++;
if (!$this->_fetch()) {
$this->EOF = true;
}
}
}
return !($this->EOF);
}
$this->fields = false;
$this->EOF = true;
return false;
}
/**
* Get the value of a field in the current row by column name.
* Will not work if ADODB_FETCH_MODE is set to ADODB_FETCH_NUM.
*
* @param colname is the field to access
*
* @return the value of $colname column
*/
function Fields($colname) {
return $this->fields[$colname];
}
/**
* Defines the function to use for table fields case conversion
* depending on ADODB_ASSOC_CASE
* @return string strtolower/strtoupper or false if no conversion needed
*/
protected function AssocCaseConvertFunction($case = ADODB_ASSOC_CASE) {
switch($case) {
case ADODB_ASSOC_CASE_UPPER:
return 'strtoupper';
case ADODB_ASSOC_CASE_LOWER:
return 'strtolower';
case ADODB_ASSOC_CASE_NATIVE:
default:
return false;
}
}
/**
* Builds the bind array associating keys to recordset fields
*
* @param int $upper Case for the array keys, defaults to uppercase
* (see ADODB_ASSOC_CASE_xxx constants)
*/
function GetAssocKeys($upper = ADODB_ASSOC_CASE) {
if ($this->bind) {
return;
}
$this->bind = array();
// Define case conversion function for ASSOC fetch mode
$fn_change_case = $this->AssocCaseConvertFunction($upper);
// Build the bind array
for ($i=0; $i < $this->_numOfFields; $i++) {
$o = $this->FetchField($i);
// Set the array's key
if(is_numeric($o->name)) {
// Just use the field ID
$key = $i;
}
elseif( $fn_change_case ) {
// Convert the key's case
$key = $fn_change_case($o->name);
}
else {
$key = $o->name;
}
$this->bind[$key] = $i;
}
}
/**
* Use associative array to get fields array for databases that do not support
* associative arrays. Submitted by Paolo S. Asioli paolo.asioli#libero.it
*
* @param int $upper Case for the array keys, defaults to uppercase
* (see ADODB_ASSOC_CASE_xxx constants)
*/
function GetRowAssoc($upper = ADODB_ASSOC_CASE) {
$record = array();
$this->GetAssocKeys($upper);
foreach($this->bind as $k => $v) {
if( array_key_exists( $v, $this->fields ) ) {
$record[$k] = $this->fields[$v];
} elseif( array_key_exists( $k, $this->fields ) ) {
$record[$k] = $this->fields[$k];
} else {
# This should not happen... trigger error ?
$record[$k] = null;
}
}
return $record;
}
/**
* Clean up recordset
*
* @return true or false
*/
function Close() {
// free connection object - this seems to globally free the object
// and not merely the reference, so don't do this...
// $this->connection = false;
if (!$this->_closed) {
$this->_closed = true;
return $this->_close();
} else
return true;
}
/**
* synonyms RecordCount and RowCount
*
* @return the number of rows or -1 if this is not supported
*/
function RecordCount() {
return $this->_numOfRows;
}
/*
* If we are using PageExecute(), this will return the maximum possible rows
* that can be returned when paging a recordset.
*/
function MaxRecordCount() {
return ($this->_maxRecordCount) ? $this->_maxRecordCount : $this->RecordCount();
}
/**
* synonyms RecordCount and RowCount
*
* @return the number of rows or -1 if this is not supported
*/
function RowCount() {
return $this->_numOfRows;
}
/**
* Portable RecordCount. Pablo Roca
*
* @return the number of records from a previous SELECT. All databases support this.
*
* But aware possible problems in multiuser environments. For better speed the table
* must be indexed by the condition. Heavy test this before deploying.
*/
function PO_RecordCount($table="", $condition="") {
$lnumrows = $this->_numOfRows;
// the database doesn't support native recordcount, so we do a workaround
if ($lnumrows == -1 && $this->connection) {
IF ($table) {
if ($condition) {
$condition = " WHERE " . $condition;
}
$resultrows = $this->connection->Execute("SELECT COUNT(*) FROM $table $condition");
if ($resultrows) {
$lnumrows = reset($resultrows->fields);
}
}
}
return $lnumrows;
}
/**
* @return the current row in the recordset. If at EOF, will return the last row. 0-based.
*/
function CurrentRow() {
return $this->_currentRow;
}
/**
* synonym for CurrentRow -- for ADO compat
*
* @return the current row in the recordset. If at EOF, will return the last row. 0-based.
*/
function AbsolutePosition() {
return $this->_currentRow;
}
/**
* @return the number of columns in the recordset. Some databases will set this to 0
* if no records are returned, others will return the number of columns in the query.
*/
function FieldCount() {
return $this->_numOfFields;
}
/**
* Get the ADOFieldObject of a specific column.
*
* @param fieldoffset is the column position to access(0-based).
*
* @return the ADOFieldObject for that column, or false.
*/
function FetchField($fieldoffset = -1) {
// must be defined by child class
return false;
}
/**
* Get the ADOFieldObjects of all columns in an array.
*
*/
function FieldTypesArray() {
$arr = array();
for ($i=0, $max=$this->_numOfFields; $i < $max; $i++)
$arr[] = $this->FetchField($i);
return $arr;
}
/**
* Return the fields array of the current row as an object for convenience.
* The default case is lowercase field names.
*
* @return the object with the properties set to the fields of the current row
*/
function FetchObj() {
$o = $this->FetchObject(false);
return $o;
}
/**
* Return the fields array of the current row as an object for convenience.
* The default case is uppercase.
*
* @param $isupper to set the object property names to uppercase
*
* @return the object with the properties set to the fields of the current row
*/
function FetchObject($isupper=true) {
if (empty($this->_obj)) {
$this->_obj = new ADOFetchObj();
$this->_names = array();
for ($i=0; $i <$this->_numOfFields; $i++) {
$f = $this->FetchField($i);
$this->_names[] = $f->name;
}
}
$i = 0;
if (PHP_VERSION >= 5) {
$o = clone($this->_obj);
} else {
$o = $this->_obj;
}
for ($i=0; $i <$this->_numOfFields; $i++) {
$name = $this->_names[$i];
if ($isupper) {
$n = strtoupper($name);
} else {
$n = $name;
}
$o->$n = $this->Fields($name);
}
return $o;
}
/**
* Return the fields array of the current row as an object for convenience.
* The default is lower-case field names.
*
* @return the object with the properties set to the fields of the current row,
* or false if EOF
*
* Fixed bug reported by tim@orotech.net
*/
function FetchNextObj() {
$o = $this->FetchNextObject(false);
return $o;
}
/**
* Return the fields array of the current row as an object for convenience.
* The default is upper case field names.
*
* @param $isupper to set the object property names to uppercase
*
* @return the object with the properties set to the fields of the current row,
* or false if EOF
*
* Fixed bug reported by tim@orotech.net
*/
function FetchNextObject($isupper=true) {
$o = false;
if ($this->_numOfRows != 0 && !$this->EOF) {
$o = $this->FetchObject($isupper);
$this->_currentRow++;
if ($this->_fetch()) {
return $o;
}
}
$this->EOF = true;
return $o;
}
/**
* Get the metatype of the column. This is used for formatting. This is because
* many databases use different names for the same type, so we transform the original
* type to our standardised version which uses 1 character codes:
*
* @param t is the type passed in. Normally is ADOFieldObject->type.
* @param len is the maximum length of that field. This is because we treat character
* fields bigger than a certain size as a 'B' (blob).
* @param fieldobj is the field object returned by the database driver. Can hold
* additional info (eg. primary_key for mysql).
*
* @return the general type of the data:
* C for character < 250 chars
* X for teXt (>= 250 chars)
* B for Binary
* N for numeric or floating point
* D for date
* T for timestamp
* L for logical/Boolean
* I for integer
* R for autoincrement counter/integer
*
*
*/
function MetaType($t,$len=-1,$fieldobj=false) {
if (is_object($t)) {
$fieldobj = $t;
$t = $fieldobj->type;
$len = $fieldobj->max_length;
}
// changed in 2.32 to hashing instead of switch stmt for speed...
static $typeMap = array(
'VARCHAR' => 'C',
'VARCHAR2' => 'C',
'CHAR' => 'C',
'C' => 'C',
'STRING' => 'C',
'NCHAR' => 'C',
'NVARCHAR' => 'C',
'VARYING' => 'C',
'BPCHAR' => 'C',
'CHARACTER' => 'C',
'INTERVAL' => 'C', # Postgres
'MACADDR' => 'C', # postgres
'VAR_STRING' => 'C', # mysql
##
'LONGCHAR' => 'X',
'TEXT' => 'X',
'NTEXT' => 'X',
'M' => 'X',
'X' => 'X',
'CLOB' => 'X',
'NCLOB' => 'X',
'LVARCHAR' => 'X',
##
'BLOB' => 'B',
'IMAGE' => 'B',
'BINARY' => 'B',
'VARBINARY' => 'B',
'LONGBINARY' => 'B',
'B' => 'B',
##
'YEAR' => 'D', // mysql
'DATE' => 'D',
'D' => 'D',
##
'UNIQUEIDENTIFIER' => 'C', # MS SQL Server
##
'SMALLDATETIME' => 'T',
'TIME' => 'T',
'TIMESTAMP' => 'T',
'DATETIME' => 'T',
'DATETIME2' => 'T',
'TIMESTAMPTZ' => 'T',
'T' => 'T',
'TIMESTAMP WITHOUT TIME ZONE' => 'T', // postgresql
##
'BOOL' => 'L',
'BOOLEAN' => 'L',
'BIT' => 'L',
'L' => 'L',
##
'COUNTER' => 'R',
'R' => 'R',
'SERIAL' => 'R', // ifx
'INT IDENTITY' => 'R',
##
'INT' => 'I',
'INT2' => 'I',
'INT4' => 'I',
'INT8' => 'I',
'INTEGER' => 'I',
'INTEGER UNSIGNED' => 'I',
'SHORT' => 'I',
'TINYINT' => 'I',
'SMALLINT' => 'I',
'I' => 'I',
##
'LONG' => 'N', // interbase is numeric, oci8 is blob
'BIGINT' => 'N', // this is bigger than PHP 32-bit integers
'DECIMAL' => 'N',
'DEC' => 'N',
'REAL' => 'N',
'DOUBLE' => 'N',
'DOUBLE PRECISION' => 'N',
'SMALLFLOAT' => 'N',
'FLOAT' => 'N',
'NUMBER' => 'N',
'NUM' => 'N',
'NUMERIC' => 'N',
'MONEY' => 'N',
## informix 9.2
'SQLINT' => 'I',
'SQLSERIAL' => 'I',
'SQLSMINT' => 'I',
'SQLSMFLOAT' => 'N',
'SQLFLOAT' => 'N',
'SQLMONEY' => 'N',
'SQLDECIMAL' => 'N',
'SQLDATE' => 'D',
'SQLVCHAR' => 'C',
'SQLCHAR' => 'C',
'SQLDTIME' => 'T',
'SQLINTERVAL' => 'N',
'SQLBYTES' => 'B',
'SQLTEXT' => 'X',
## informix 10
"SQLINT8" => 'I8',
"SQLSERIAL8" => 'I8',
"SQLNCHAR" => 'C',
"SQLNVCHAR" => 'C',
"SQLLVARCHAR" => 'X',
"SQLBOOL" => 'L'
);
$tmap = false;
$t = strtoupper($t);
$tmap = (isset($typeMap[$t])) ? $typeMap[$t] : 'N';
switch ($tmap) {
case 'C':
// is the char field is too long, return as text field...
if ($this->blobSize >= 0) {
if ($len > $this->blobSize) {
return 'X';
}
} else if ($len > 250) {
return 'X';
}
return 'C';
case 'I':
if (!empty($fieldobj->primary_key)) {
return 'R';
}
return 'I';
case false:
return 'N';
case 'B':
if (isset($fieldobj->binary)) {
return ($fieldobj->binary) ? 'B' : 'X';
}
return 'B';
case 'D':
if (!empty($this->connection) && !empty($this->connection->datetime)) {
return 'T';
}
return 'D';
default:
if ($t == 'LONG' && $this->dataProvider == 'oci8') {
return 'B';
}
return $tmap;
}
}
/**
* Convert case of field names associative array, if needed
* @return void
*/
protected function _updatefields()
{
if( empty($this->fields)) {
return;
}
// Determine case conversion function
$fn_change_case = $this->AssocCaseConvertFunction();
if(!$fn_change_case) {
// No conversion needed
return;
}
$arr = array();
// Change the case
foreach($this->fields as $k => $v) {
if (!is_integer($k)) {
$k = $fn_change_case($k);
}
$arr[$k] = $v;
}
$this->fields = $arr;
}
function _close() {}
/**
* set/returns the current recordset page when paginating
*/
function AbsolutePage($page=-1) {
if ($page != -1) {
$this->_currentPage = $page;
}
return $this->_currentPage;
}
/**
* set/returns the status of the atFirstPage flag when paginating
*/
function AtFirstPage($status=false) {
if ($status != false) {
$this->_atFirstPage = $status;
}
return $this->_atFirstPage;
}
function LastPageNo($page = false) {
if ($page != false) {
$this->_lastPageNo = $page;
}
return $this->_lastPageNo;
}
/**
* set/returns the status of the atLastPage flag when paginating
*/
function AtLastPage($status=false) {
if ($status != false) {
$this->_atLastPage = $status;
}
return $this->_atLastPage;
}
} // end class ADORecordSet
//==============================================================================================
// CLASS ADORecordSet_array
//==============================================================================================
/**
* This class encapsulates the concept of a recordset created in memory
* as an array. This is useful for the creation of cached recordsets.
*
* Note that the constructor is different from the standard ADORecordSet
*/
class ADORecordSet_array extends ADORecordSet
{
var $databaseType = 'array';
var $_array; // holds the 2-dimensional data array
var $_types; // the array of types of each column (C B I L M)
var $_colnames; // names of each column in array
var $_skiprow1; // skip 1st row because it holds column names
var $_fieldobjects; // holds array of field objects
var $canSeek = true;
var $affectedrows = false;
var $insertid = false;
var $sql = '';
var $compat = false;
/**
* Constructor
*/
function __construct($fakeid=1) {
global $ADODB_FETCH_MODE,$ADODB_COMPAT_FETCH;
// fetch() on EOF does not delete $this->fields
$this->compat = !empty($ADODB_COMPAT_FETCH);
parent::__construct($fakeid); // fake queryID
$this->fetchMode = $ADODB_FETCH_MODE;
}
function _transpose($addfieldnames=true) {
global $ADODB_INCLUDED_LIB;
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
$hdr = true;
$fobjs = $addfieldnames ? $this->_fieldobjects : false;
adodb_transpose($this->_array, $newarr, $hdr, $fobjs);
//adodb_pr($newarr);
$this->_skiprow1 = false;
$this->_array = $newarr;
$this->_colnames = $hdr;
adodb_probetypes($newarr,$this->_types);
$this->_fieldobjects = array();
foreach($hdr as $k => $name) {
$f = new ADOFieldObject();
$f->name = $name;
$f->type = $this->_types[$k];
$f->max_length = -1;
$this->_fieldobjects[] = $f;
}
$this->fields = reset($this->_array);
$this->_initrs();
}
/**
* Setup the array.
*
* @param array is a 2-dimensional array holding the data.
* The first row should hold the column names
* unless paramter $colnames is used.
* @param typearr holds an array of types. These are the same types
* used in MetaTypes (C,B,L,I,N).
* @param [colnames] array of column names. If set, then the first row of
* $array should not hold the column names.
*/
function InitArray($array,$typearr,$colnames=false) {
$this->_array = $array;
$this->_types = $typearr;
if ($colnames) {
$this->_skiprow1 = false;
$this->_colnames = $colnames;
} else {
$this->_skiprow1 = true;
$this->_colnames = $array[0];
}
$this->Init();
}
/**
* Setup the Array and datatype file objects
*
* @param array is a 2-dimensional array holding the data.
* The first row should hold the column names
* unless paramter $colnames is used.
* @param fieldarr holds an array of ADOFieldObject's.
*/
function InitArrayFields(&$array,&$fieldarr) {
$this->_array = $array;
$this->_skiprow1= false;
if ($fieldarr) {
$this->_fieldobjects = $fieldarr;
}
$this->Init();
}
function GetArray($nRows=-1) {
if ($nRows == -1 && $this->_currentRow <= 0 && !$this->_skiprow1) {
return $this->_array;
} else {
$arr = ADORecordSet::GetArray($nRows);
return $arr;
}
}
function _initrs() {
$this->_numOfRows = sizeof($this->_array);
if ($this->_skiprow1) {
$this->_numOfRows -= 1;
}
$this->_numOfFields = (isset($this->_fieldobjects))
? sizeof($this->_fieldobjects)
: sizeof($this->_types);
}
/* Use associative array to get fields array */
function Fields($colname) {
$mode = isset($this->adodbFetchMode) ? $this->adodbFetchMode : $this->fetchMode;
if ($mode & ADODB_FETCH_ASSOC) {
if (!isset($this->fields[$colname]) && !is_null($this->fields[$colname])) {
$colname = strtolower($colname);
}
return $this->fields[$colname];
}
if (!$this->bind) {
$this->bind = array();
for ($i=0; $i < $this->_numOfFields; $i++) {
$o = $this->FetchField($i);
$this->bind[strtoupper($o->name)] = $i;
}
}
return $this->fields[$this->bind[strtoupper($colname)]];
}
function FetchField($fieldOffset = -1) {
if (isset($this->_fieldobjects)) {
return $this->_fieldobjects[$fieldOffset];
}
$o = new ADOFieldObject();
$o->name = $this->_colnames[$fieldOffset];
$o->type = $this->_types[$fieldOffset];
$o->max_length = -1; // length not known
return $o;
}
function _seek($row) {
if (sizeof($this->_array) && 0 <= $row && $row < $this->_numOfRows) {
$this->_currentRow = $row;
if ($this->_skiprow1) {
$row += 1;
}
$this->fields = $this->_array[$row];
return true;
}
return false;
}
function MoveNext() {
if (!$this->EOF) {
$this->_currentRow++;
$pos = $this->_currentRow;
if ($this->_numOfRows <= $pos) {
if (!$this->compat) {
$this->fields = false;
}
} else {
if ($this->_skiprow1) {
$pos += 1;
}
$this->fields = $this->_array[$pos];
return true;
}
$this->EOF = true;
}
return false;
}
function _fetch() {
$pos = $this->_currentRow;
if ($this->_numOfRows <= $pos) {
if (!$this->compat) {
$this->fields = false;
}
return false;
}
if ($this->_skiprow1) {
$pos += 1;
}
$this->fields = $this->_array[$pos];
return true;
}
function _close() {
return true;
}
} // ADORecordSet_array
//==============================================================================================
// HELPER FUNCTIONS
//==============================================================================================
/**
* Synonym for ADOLoadCode. Private function. Do not use.
*
* @deprecated
*/
function ADOLoadDB($dbType) {
return ADOLoadCode($dbType);
}
/**
* Load the code for a specific database driver. Private function. Do not use.
*/
function ADOLoadCode($dbType) {
global $ADODB_LASTDB;
if (!$dbType) {
return false;
}
$db = strtolower($dbType);
switch ($db) {
case 'ado':
if (PHP_VERSION >= 5) {
$db = 'ado5';
}
$class = 'ado';
break;
case 'ifx':
case 'maxsql':
$class = $db = 'mysqlt';
break;
case 'pgsql':
case 'postgres':
$class = $db = 'postgres8';
break;
default:
$class = $db; break;
}
$file = "drivers/adodb-$db.inc.php";
@include_once(ADODB_DIR . '/' . $file);
$ADODB_LASTDB = $class;
if (class_exists("ADODB_" . $class)) {
return $class;
}
//ADOConnection::outp(adodb_pr(get_declared_classes(),true));
if (!file_exists($file)) {
ADOConnection::outp("Missing file: $file");
} else {
ADOConnection::outp("Syntax error in file: $file");
}
return false;
}
/**
* synonym for ADONewConnection for people like me who cannot remember the correct name
*/
function NewADOConnection($db='') {
$tmp = ADONewConnection($db);
return $tmp;
}
/**
* Instantiate a new Connection class for a specific database driver.
*
* @param [db] is the database Connection object to create. If undefined,
* use the last database driver that was loaded by ADOLoadCode().
*
* @return the freshly created instance of the Connection class.
*/
function ADONewConnection($db='') {
global $ADODB_NEWCONNECTION, $ADODB_LASTDB;
if (!defined('ADODB_ASSOC_CASE')) {
define('ADODB_ASSOC_CASE', ADODB_ASSOC_CASE_NATIVE);
}
$errorfn = (defined('ADODB_ERROR_HANDLER')) ? ADODB_ERROR_HANDLER : false;
if (($at = strpos($db,'://')) !== FALSE) {
$origdsn = $db;
$fakedsn = 'fake'.substr($origdsn,$at);
if (($at2 = strpos($origdsn,'@/')) !== FALSE) {
// special handling of oracle, which might not have host
$fakedsn = str_replace('@/','@adodb-fakehost/',$fakedsn);
}
if ((strpos($origdsn, 'sqlite')) !== FALSE && stripos($origdsn, '%2F') === FALSE) {
// special handling for SQLite, it only might have the path to the database file.
// If you try to connect to a SQLite database using a dsn
// like 'sqlite:///path/to/database', the 'parse_url' php function
// will throw you an exception with a message such as "unable to parse url"
list($scheme, $path) = explode('://', $origdsn);
$dsna['scheme'] = $scheme;
if ($qmark = strpos($path,'?')) {
$dsn['query'] = substr($path,$qmark+1);
$path = substr($path,0,$qmark);
}
$dsna['path'] = '/' . urlencode($path);
} else
$dsna = @parse_url($fakedsn);
if (!$dsna) {
return false;
}
$dsna['scheme'] = substr($origdsn,0,$at);
if ($at2 !== FALSE) {
$dsna['host'] = '';
}
if (strncmp($origdsn,'pdo',3) == 0) {
$sch = explode('_',$dsna['scheme']);
if (sizeof($sch)>1) {
$dsna['host'] = isset($dsna['host']) ? rawurldecode($dsna['host']) : '';
if ($sch[1] == 'sqlite') {
$dsna['host'] = rawurlencode($sch[1].':'.rawurldecode($dsna['host']));
} else {
$dsna['host'] = rawurlencode($sch[1].':host='.rawurldecode($dsna['host']));
}
$dsna['scheme'] = 'pdo';
}
}
$db = @$dsna['scheme'];
if (!$db) {
return false;
}
$dsna['host'] = isset($dsna['host']) ? rawurldecode($dsna['host']) : '';
$dsna['user'] = isset($dsna['user']) ? rawurldecode($dsna['user']) : '';
$dsna['pass'] = isset($dsna['pass']) ? rawurldecode($dsna['pass']) : '';
$dsna['path'] = isset($dsna['path']) ? rawurldecode(substr($dsna['path'],1)) : ''; # strip off initial /
if (isset($dsna['query'])) {
$opt1 = explode('&',$dsna['query']);
foreach($opt1 as $k => $v) {
$arr = explode('=',$v);
$opt[$arr[0]] = isset($arr[1]) ? rawurldecode($arr[1]) : 1;
}
} else {
$opt = array();
}
}
/*
* phptype: Database backend used in PHP (mysql, odbc etc.)
* dbsyntax: Database used with regards to SQL syntax etc.
* protocol: Communication protocol to use (tcp, unix etc.)
* hostspec: Host specification (hostname[:port])
* database: Database to use on the DBMS server
* username: User name for login
* password: Password for login
*/
if (!empty($ADODB_NEWCONNECTION)) {
$obj = $ADODB_NEWCONNECTION($db);
}
if(empty($obj)) {
if (!isset($ADODB_LASTDB)) {
$ADODB_LASTDB = '';
}
if (empty($db)) {
$db = $ADODB_LASTDB;
}
if ($db != $ADODB_LASTDB) {
$db = ADOLoadCode($db);
}
if (!$db) {
if (isset($origdsn)) {
$db = $origdsn;
}
if ($errorfn) {
// raise an error
$ignore = false;
$errorfn('ADONewConnection', 'ADONewConnection', -998,
"could not load the database driver for '$db'",
$db,false,$ignore);
} else {
ADOConnection::outp( "ADONewConnection: Unable to load database driver '$db'
",false);
}
return false;
}
$cls = 'ADODB_'.$db;
if (!class_exists($cls)) {
adodb_backtrace();
return false;
}
$obj = new $cls();
}
# constructor should not fail
if ($obj) {
if ($errorfn) {
$obj->raiseErrorFn = $errorfn;
}
if (isset($dsna)) {
if (isset($dsna['port'])) {
$obj->port = $dsna['port'];
}
foreach($opt as $k => $v) {
switch(strtolower($k)) {
case 'new':
$nconnect = true; $persist = true; break;
case 'persist':
case 'persistent': $persist = $v; break;
case 'debug': $obj->debug = (integer) $v; break;
#ibase
case 'role': $obj->role = $v; break;
case 'dialect': $obj->dialect = (integer) $v; break;
case 'charset': $obj->charset = $v; $obj->charSet=$v; break;
case 'buffers': $obj->buffers = $v; break;
case 'fetchmode': $obj->SetFetchMode($v); break;
#ado
case 'charpage': $obj->charPage = $v; break;
#mysql, mysqli
case 'clientflags': $obj->clientFlags = $v; break;
#mysql, mysqli, postgres
case 'port': $obj->port = $v; break;
#mysqli
case 'socket': $obj->socket = $v; break;
#oci8
case 'nls_date_format': $obj->NLS_DATE_FORMAT = $v; break;
case 'cachesecs': $obj->cacheSecs = $v; break;
case 'memcache':
$varr = explode(':',$v);
$vlen = sizeof($varr);
if ($vlen == 0) {
break;
}
$obj->memCache = true;
$obj->memCacheHost = explode(',',$varr[0]);
if ($vlen == 1) {
break;
}
$obj->memCachePort = $varr[1];
if ($vlen == 2) {
break;
}
$obj->memCacheCompress = $varr[2] ? true : false;
break;
}
}
if (empty($persist)) {
$ok = $obj->Connect($dsna['host'], $dsna['user'], $dsna['pass'], $dsna['path']);
} else if (empty($nconnect)) {
$ok = $obj->PConnect($dsna['host'], $dsna['user'], $dsna['pass'], $dsna['path']);
} else {
$ok = $obj->NConnect($dsna['host'], $dsna['user'], $dsna['pass'], $dsna['path']);
}
if (!$ok) {
return false;
}
}
}
return $obj;
}
// $perf == true means called by NewPerfMonitor(), otherwise for data dictionary
function _adodb_getdriver($provider,$drivername,$perf=false) {
switch ($provider) {
case 'odbtp':
if (strncmp('odbtp_',$drivername,6)==0) {
return substr($drivername,6);
}
case 'odbc' :
if (strncmp('odbc_',$drivername,5)==0) {
return substr($drivername,5);
}
case 'ado' :
if (strncmp('ado_',$drivername,4)==0) {
return substr($drivername,4);
}
case 'native':
break;
default:
return $provider;
}
switch($drivername) {
case 'mysqlt':
case 'mysqli':
$drivername='mysql';
break;
case 'postgres7':
case 'postgres8':
$drivername = 'postgres';
break;
case 'firebird15':
$drivername = 'firebird';
break;
case 'oracle':
$drivername = 'oci8';
break;
case 'access':
if ($perf) {
$drivername = '';
}
break;
case 'db2' :
case 'sapdb' :
break;
default:
$drivername = 'generic';
break;
}
return $drivername;
}
function NewPerfMonitor(&$conn) {
$drivername = _adodb_getdriver($conn->dataProvider,$conn->databaseType,true);
if (!$drivername || $drivername == 'generic') {
return false;
}
include_once(ADODB_DIR.'/adodb-perf.inc.php');
@include_once(ADODB_DIR."/perf/perf-$drivername.inc.php");
$class = "Perf_$drivername";
if (!class_exists($class)) {
return false;
}
$perf = new $class($conn);
return $perf;
}
function NewDataDictionary(&$conn,$drivername=false) {
if (!$drivername) {
$drivername = _adodb_getdriver($conn->dataProvider,$conn->databaseType);
}
include_once(ADODB_DIR.'/adodb-lib.inc.php');
include_once(ADODB_DIR.'/adodb-datadict.inc.php');
$path = ADODB_DIR."/datadict/datadict-$drivername.inc.php";
if (!file_exists($path)) {
ADOConnection::outp("Dictionary driver '$path' not available");
return false;
}
include_once($path);
$class = "ADODB2_$drivername";
$dict = new $class();
$dict->dataProvider = $conn->dataProvider;
$dict->connection = $conn;
$dict->upperName = strtoupper($drivername);
$dict->quote = $conn->nameQuote;
if (!empty($conn->_connectionID)) {
$dict->serverInfo = $conn->ServerInfo();
}
return $dict;
}
/*
Perform a print_r, with pre tags for better formatting.
*/
function adodb_pr($var,$as_string=false) {
if ($as_string) {
ob_start();
}
if (isset($_SERVER['HTTP_USER_AGENT'])) {
echo " \n";print_r($var);echo "
\n";
} else {
print_r($var);
}
if ($as_string) {
$s = ob_get_contents();
ob_end_clean();
return $s;
}
}
/*
Perform a stack-crawl and pretty print it.
@param printOrArr Pass in a boolean to indicate print, or an $exception->trace array (assumes that print is true then).
@param levels Number of levels to display
*/
function adodb_backtrace($printOrArr=true,$levels=9999,$ishtml=null) {
global $ADODB_INCLUDED_LIB;
if (empty($ADODB_INCLUDED_LIB)) {
include(ADODB_DIR.'/adodb-lib.inc.php');
}
return _adodb_backtrace($printOrArr,$levels,0,$ishtml);
}
}
PK PȔ" " adodb-error.inc.phpnu W+A DB_ERROR_NOSUCHTABLE,
'Relation [\"\'].*[\"\'] already exists|Cannot insert a duplicate key into (a )?unique index.*|duplicate key.*violates unique constraint' => DB_ERROR_ALREADY_EXISTS,
'database ".+" does not exist$' => DB_ERROR_NOSUCHDB,
'(divide|division) by zero$' => DB_ERROR_DIVZERO,
'pg_atoi: error in .*: can\'t parse ' => DB_ERROR_INVALID_NUMBER,
'ttribute [\"\'].*[\"\'] not found|Relation [\"\'].*[\"\'] does not have attribute [\"\'].*[\"\']' => DB_ERROR_NOSUCHFIELD,
'(parser: parse|syntax) error at or near \"' => DB_ERROR_SYNTAX,
'referential integrity violation' => DB_ERROR_CONSTRAINT,
'deadlock detected$' => DB_ERROR_DEADLOCK,
'canceling statement due to statement timeout$' => DB_ERROR_STATEMENT_TIMEOUT,
'could not serialize access due to' => DB_ERROR_SERIALIZATION_FAILURE
);
reset($error_regexps);
foreach ($error_regexps as $regexp => $code) {
if (preg_match("/$regexp/mi", $errormsg)) {
return $code;
}
}
// Fall back to DB_ERROR if there was no mapping.
return DB_ERROR;
}
function adodb_error_odbc()
{
static $MAP = array(
'01004' => DB_ERROR_TRUNCATED,
'07001' => DB_ERROR_MISMATCH,
'21S01' => DB_ERROR_MISMATCH,
'21S02' => DB_ERROR_MISMATCH,
'22003' => DB_ERROR_INVALID_NUMBER,
'22008' => DB_ERROR_INVALID_DATE,
'22012' => DB_ERROR_DIVZERO,
'23000' => DB_ERROR_CONSTRAINT,
'24000' => DB_ERROR_INVALID,
'34000' => DB_ERROR_INVALID,
'37000' => DB_ERROR_SYNTAX,
'42000' => DB_ERROR_SYNTAX,
'IM001' => DB_ERROR_UNSUPPORTED,
'S0000' => DB_ERROR_NOSUCHTABLE,
'S0001' => DB_ERROR_NOT_FOUND,
'S0002' => DB_ERROR_NOSUCHTABLE,
'S0011' => DB_ERROR_ALREADY_EXISTS,
'S0012' => DB_ERROR_NOT_FOUND,
'S0021' => DB_ERROR_ALREADY_EXISTS,
'S0022' => DB_ERROR_NOT_FOUND,
'S1000' => DB_ERROR_NOSUCHTABLE,
'S1009' => DB_ERROR_INVALID,
'S1090' => DB_ERROR_INVALID,
'S1C00' => DB_ERROR_NOT_CAPABLE
);
return $MAP;
}
function adodb_error_ibase()
{
static $MAP = array(
-104 => DB_ERROR_SYNTAX,
-150 => DB_ERROR_ACCESS_VIOLATION,
-151 => DB_ERROR_ACCESS_VIOLATION,
-155 => DB_ERROR_NOSUCHTABLE,
-157 => DB_ERROR_NOSUCHFIELD,
-158 => DB_ERROR_VALUE_COUNT_ON_ROW,
-170 => DB_ERROR_MISMATCH,
-171 => DB_ERROR_MISMATCH,
-172 => DB_ERROR_INVALID,
-204 => DB_ERROR_INVALID,
-205 => DB_ERROR_NOSUCHFIELD,
-206 => DB_ERROR_NOSUCHFIELD,
-208 => DB_ERROR_INVALID,
-219 => DB_ERROR_NOSUCHTABLE,
-297 => DB_ERROR_CONSTRAINT,
-530 => DB_ERROR_CONSTRAINT,
-803 => DB_ERROR_CONSTRAINT,
-551 => DB_ERROR_ACCESS_VIOLATION,
-552 => DB_ERROR_ACCESS_VIOLATION,
-922 => DB_ERROR_NOSUCHDB,
-923 => DB_ERROR_CONNECT_FAILED,
-924 => DB_ERROR_CONNECT_FAILED
);
return $MAP;
}
function adodb_error_ifx()
{
static $MAP = array(
'-201' => DB_ERROR_SYNTAX,
'-206' => DB_ERROR_NOSUCHTABLE,
'-217' => DB_ERROR_NOSUCHFIELD,
'-329' => DB_ERROR_NODBSELECTED,
'-1204' => DB_ERROR_INVALID_DATE,
'-1205' => DB_ERROR_INVALID_DATE,
'-1206' => DB_ERROR_INVALID_DATE,
'-1209' => DB_ERROR_INVALID_DATE,
'-1210' => DB_ERROR_INVALID_DATE,
'-1212' => DB_ERROR_INVALID_DATE
);
return $MAP;
}
function adodb_error_oci8()
{
static $MAP = array(
1 => DB_ERROR_ALREADY_EXISTS,
900 => DB_ERROR_SYNTAX,
904 => DB_ERROR_NOSUCHFIELD,
923 => DB_ERROR_SYNTAX,
942 => DB_ERROR_NOSUCHTABLE,
955 => DB_ERROR_ALREADY_EXISTS,
1476 => DB_ERROR_DIVZERO,
1722 => DB_ERROR_INVALID_NUMBER,
2289 => DB_ERROR_NOSUCHTABLE,
2291 => DB_ERROR_CONSTRAINT,
2449 => DB_ERROR_CONSTRAINT
);
return $MAP;
}
function adodb_error_mssql()
{
static $MAP = array(
208 => DB_ERROR_NOSUCHTABLE,
2601 => DB_ERROR_ALREADY_EXISTS
);
return $MAP;
}
function adodb_error_sqlite()
{
static $MAP = array(
1 => DB_ERROR_SYNTAX
);
return $MAP;
}
function adodb_error_mysql()
{
static $MAP = array(
1004 => DB_ERROR_CANNOT_CREATE,
1005 => DB_ERROR_CANNOT_CREATE,
1006 => DB_ERROR_CANNOT_CREATE,
1007 => DB_ERROR_ALREADY_EXISTS,
1008 => DB_ERROR_CANNOT_DROP,
1045 => DB_ERROR_ACCESS_VIOLATION,
1046 => DB_ERROR_NODBSELECTED,
1049 => DB_ERROR_NOSUCHDB,
1050 => DB_ERROR_ALREADY_EXISTS,
1051 => DB_ERROR_NOSUCHTABLE,
1054 => DB_ERROR_NOSUCHFIELD,
1062 => DB_ERROR_ALREADY_EXISTS,
1064 => DB_ERROR_SYNTAX,
1100 => DB_ERROR_NOT_LOCKED,
1136 => DB_ERROR_VALUE_COUNT_ON_ROW,
1146 => DB_ERROR_NOSUCHTABLE,
1048 => DB_ERROR_CONSTRAINT,
2002 => DB_ERROR_CONNECT_FAILED,
2005 => DB_ERROR_CONNECT_FAILED
);
return $MAP;
}
PK P&