metabase_wrapper.php

来自「视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.」· PHP 代码 · 共 1,626 行 · 第 1/4 页

<?php
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1998-2004 Manuel Lemos, Tomas V.V.Cox,                 |
// | Stig. S. Bakken, Lukas Smith                                         |
// | All rights reserved.                                                 |
// +----------------------------------------------------------------------+
// | MDB is a merge of PEAR DB and Metabases that provides a unified DB   |
// | API as well as database abstraction for PHP applications.            |
// | This LICENSE is in the BSD license style.                            |
// |                                                                      |
// | Redistribution and use in source and binary forms, with or without   |
// | modification, are permitted provided that the following conditions   |
// | are met:                                                             |
// |                                                                      |
// | Redistributions of source code must retain the above copyright       |
// | notice, this list of conditions and the following disclaimer.        |
// |                                                                      |
// | 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. |
// |                                                                      |
// | Neither the name of Manuel Lemos, Tomas V.V.Cox, Stig. S. Bakken,    |
// | Lukas Smith nor the names of his contributors may be used to endorse |
// | or promote products derived from this software without specific prior|
// | written permission.                                                  |
// |                                                                      |
// | 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      |
// | REGENTS 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.                                          |
// +----------------------------------------------------------------------+
// | Author: Lukas Smith <[e-mail]>                         |
// +----------------------------------------------------------------------+
//
// $Id: metabase_wrapper.php,v 1.50.4.1 2004/01/08 13:43:02 lsmith Exp $
//

MDB::loadFile('Date');

/**
 * Wrapper that makes MDB behave like Metabase
 *
 * @package MDB
 * @category Database
 * @author  Lukas Smith <[e-mail]>
 */

$lob_error = '';

function MetabaseSetupDatabase($arguments, &$database)
{
    _convertArguments($arguments, $dsninfo, $options);
    $db =& MDB::connect($dsninfo, $options);

    if (MDB::isError($db) || !is_object($db)) {
        $database = 0;
        return($db->getMessage());
    }
    $database = $db->database;
    return('');
}

function MetabaseSetupDatabaseObject($arguments, &$db)
{
    _convertArguments($arguments, $dsninfo, $options);
    $db =& MDB::connect($dsninfo, $options);

    if (MDB::isError($db) || !is_object($db)) {
        return($db->getMessage());
    }
    return('');
}

function _convertArguments($arguments, &$dsninfo, &$options)
{
    if (isset($arguments['Type'])) {
        $dsninfo['phptype'] = $arguments['Type'];
    }
    if (isset($arguments['User'])) {
        $dsninfo['username'] = $arguments['User'];
    }
    if(isset($arguments['Password'])) {
        $dsninfo['password'] = $arguments['Password'];
    }
    if(isset($arguments['Host'])) {
        $dsninfo['hostspec'] = $arguments['Host'];
    }
    if(isset($arguments['Options']['Port'])) {
       $dsninfo['port'] = $arguments['Options']['Port'];
       unset($arguments['Options']['Port']);
    }

    if (isset($arguments['Persistent'])) {
        $options['persistent'] = TRUE;
    }
    if(isset($arguments['Debug'])) {
        $options['debug'] = $arguments['Debug'];
    }
    if(isset($arguments['DecimalPlaces'])) {
        $options['decimal_places'] = $arguments['DecimalPlaces'];
    }
    if(isset($arguments['LOBBufferLength'])) {
        $options['LOBbufferlength'] = $arguments['LOBBufferLength'];
    }
    if(isset($arguments['LogLineBreak'])) {
        $options['loglinebreak'] = $arguments['LogLineBreak'];
    }

    $options['seqname_format'] = '_sequence_%s';
    if(isset($arguments['Options']) && is_array($arguments['Options'])) {
       $options = array_merge($options, $arguments['Options']);
    }
}

function MetabaseCloseSetup($database)
{
    global $_MDB_databases;

    $_MDB_databases[$database]->disconnect();
    unset($_MDB_databases[$database]);
}

function MetabaseQuery($database, $query)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->query($query);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('Query', $result->getMessage());
        return(0);
    } else {
        return($result);
    }
}

function MetabaseQueryField($database, $query, &$field, $type = 'text')
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->queryOne($query, $type);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QueryField', $result->getMessage());
        return(0);
    } else {
        $field = $result;
        return(1);
    }
}

function MetabaseQueryRow($database, $query, &$row, $types = '')
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->queryRow($query, $types);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QueryRow', $result->getMessage());
        return(0);
    } else {
        $row = $result;
        return(1);
    }
}

function MetabaseQueryColumn($database, $query, &$column, $type = 'text')
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->queryCol($query, $type);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QueryColumn', $result->getMessage());
        return(0);
    } else {
        $column = $result;
        return(1);
    }
}

function MetabaseQueryAll($database, $query, &$all, $types = '')
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->queryAll($query, $types);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QueryAll', $result->getMessage());
        return(0);
    } else {
        $all = $result;
        return(1);
    }
}

function MetabaseReplace($database, $table, &$fields)
{
    global $_MDB_databases;
    for($count = count($fields), reset($fields), $field = 0;
        $field < $count;
        next($fields), $field++)
    {
        $name = key($fields);
        if(!isset($fields[$name]['Type'])) {
            $fields[$name]['Type'] = 'text';
        }
    }
    $result = $_MDB_databases[$database]->replace($table, $fields);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('Replace', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabasePrepareQuery($database, $query)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->prepareQuery($query);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('PrepareQuery', $result->getMessage());
        return(0);
    } else {
        return($result);
    }
}

function MetabaseFreePreparedQuery($database, $prepared_query)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->freePreparedQuery($prepared_query);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('FreePreparedQuery', $result->getMessage());
        return(0);
    } else {
        return($result);
    }
}

function MetabaseExecuteQuery($database, $prepared_query)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->executeQuery($prepared_query);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('ExecuteQuery', $result->getMessage());
        return(0);
    } else {
        return($result);
    }
}

function MetabaseQuerySet($database, $prepared_query, $parameter, $type, $value, $is_null = 0, $field = '')
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParam($prepared_query, $parameter, $type, $value, $is_null, $field);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySet', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetNull($database, $prepared_query, $parameter, $type)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamNull($prepared_query, $parameter, $type);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetNull', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetText($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamText($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetText', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetCLOB($database, $prepared_query, $parameter, $value, $field)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamClob($prepared_query, $parameter, $value, $field);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetCLOB', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetBLOB($database, $prepared_query, $parameter, $value, $field)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamBlob($prepared_query, $parameter, $value, $field);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetBLOB', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetInteger($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamInteger($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetInteger', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetBoolean($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamBoolean($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetBoolean', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetDate($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamDate($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetDate(', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetTimestamp($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamTimestamp($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetTimestamp', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetTime($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamTime($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetTime', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetFloat($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamFloat($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetFloat', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseQuerySetDecimal($database, $prepared_query, $parameter, $value)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->setParamDecimal($prepared_query, $parameter, $value);
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('QuerySetDecimal', $result->getMessage());
        return(0);
    } else {
        return(1);
    }
}

function MetabaseAffectedRows($database, &$affected_rows)
{
    global $_MDB_databases;
    $result = $_MDB_databases[$database]->affectedRows();
    if (MDB::isError($result)) {
        $_MDB_databases[$database]->setError('AffectedRows', $result->getMessage());
        return(0);
    } else {
        $affected_rows = $result;
        return(1);