/* Verify sqlite3 runtime version */
static svn_error_t *
test_sqlite_version(apr_pool_t *scratch_pool)
{
  printf("DBG: Using Sqlite %s\n", sqlite3_libversion());

  if (sqlite3_libversion_number() != SQLITE_VERSION_NUMBER)
    printf("DBG: Compiled against Sqlite %s\n", SQLITE_VERSION);

  if (sqlite3_libversion_number() < SQLITE_VERSION_NUMBER)
    return svn_error_createf(SVN_ERR_TEST_FAILED, NULL,
            "Compiled against Sqlite %s (at runtime we have Sqlite %s)",
            SQLITE_VERSION, sqlite3_libversion());

#if !SQLITE_VERSION_AT_LEAST(3, 7, 9)
  return svn_error_create(SVN_ERR_TEST_FAILED, NULL,
        "Sqlite upgrade recommended:\n"
        "****************************************************************\n"
        "*   Subversion needs at least SQLite 3.7.9 to work optimally   *\n"
        "*                                                              *\n"
        "* With older versions, at least some queries that are expected *\n"
        "* to be using an index are not. This makes some operations use *\n"
        "* every node in the working copy instead of just one.          *\n"
        "*                                                              *\n"
        "* While Subversion works correctly in this case, you may see   *\n"
        "* slowdowns of WELL MORE THAN 1000* in some cases!             *\n"
        "*                                                              *\n"
        "*                                                              *\n"
        "*                SQLITE UPGRADE RECOMMENDED                    *\n"
        "****************************************************************\n");
#else
  return SVN_NO_ERROR;
#endif
}
int main(int argc, char *argv[]) {
    sqlite3 *db = NULL;
    int res = 0;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <database name>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    // Inizializzazione della libreria
    if (sqlite3_initialize() != SQLITE_OK) {
        fprintf(stderr, "Err. Unable to initialize the library\n");
        exit(EXIT_FAILURE);
    }

    // Creazione della connessione al database
    res = sqlite3_open(argv[1], &db);

    if (res != SQLITE_OK) {
        fprintf(stderr, "Err. can't create database: %s\n", sqlite3_errmsg(db));
        sqlite3_close(db);
        exit(EXIT_FAILURE);
    }

    printf("Library \'%s\' successfully initialized..\n", sqlite3_libversion());
    printf("Database \'%s\' successfully created.\n", argv[1]);

    // Close database connection
    if (sqlite3_close(db) == SQLITE_OK)
        puts("Closed database connection");

    sqlite3_shutdown();

    return(EXIT_SUCCESS);
}
Beispiel #3
0
//' RSQLite version
//'
//' @return A character vector containing header and library versions of
//'   RSQLite.
//' @export
//' @examples
//' RSQLite::rsqliteVersion()
// [[Rcpp::export]]
CharacterVector rsqliteVersion() {
  return
    CharacterVector::create(
      _["header"] = SQLITE_VERSION,
      _["library"] = sqlite3_libversion()
    );
}
int cSQLiteDatabase::initialize(){
    int ret;
    const char* dbdir = (cUPnPConfig::get()->mDatabaseFolder) ? cUPnPConfig::get()->mDatabaseFolder : cPluginUpnp::getConfigDirectory();
    cString File = cString::sprintf("%s/%s", dbdir, SQLITE_DB_FILE);
    if ((ret = sqlite3_open(File, &this->mDatabase))){
        ERROR("Unable to open database file %s (Error code: %d)!", *File, ret);
        sqlite3_close(this->mDatabase);
        return -1;
    }
	char* Error;
	if (sqlite3_exec(this->mDatabase, "PRAGMA synchronous = OFF", NULL, NULL, &Error)){
		ERROR("Error while setting PRAGMA OFF: %s", Error);
	}
	if (sqlite3_exec(this->mDatabase, "PRAGMA journal_mode = MEMORY", NULL, NULL, &Error)){
		ERROR("Error while setting journal mode to memory: %s", Error);
	}
    MESSAGE(VERBOSE_SDK,"Database file %s opened. SQLITE version: %s", *File, sqlite3_libversion());
    if (this->initializeTables()){
        ERROR("Error while creating tables");
        return -1;
    }
    else if(this->initializeTriggers()){
        ERROR("Error while setting triggers");
        return -1;
    }
    return 0;
}
string WrapperSpatialite::versions(void) const
{
    return string("SQLite3 version ") + sqlite3_libversion() + "\n" +
           "Spatialite version " + spatialite_version() + "\n";
//			       "Proj4 version " + proj4_version() + "\n" +
//			       "Geos version " + geos_version() + "\n";
}
Beispiel #6
0
Array c_SQLite3::t_version() {
  INSTANCE_METHOD_INJECTION_BUILTIN(SQLite3, SQLite3::version);
  Array ret;
  ret.set("versionString", String((char*)sqlite3_libversion(), CopyString));
  ret.set("versionNumber", (int64)sqlite3_libversion_number());
  return ret;
}
Beispiel #7
0
BOOL CAboutTabDlg::OnInitDialog()
{
	CBBTabPanel::OnInitDialog();

	CVersion lVersion;
	CString lStr;
	GetDlgItemText(IDC_ABOUT_VERSION_STATIC, lStr);
	lVersion.GetVersionString(lStr);

#ifdef _FREE
	//lStr = "Benubird PDF Version";
#endif

	// ----------------------
	// Add the version number for QPL
	// KDA: 07/07/2009
	// ----------------------
	DebenuPDFLibraryAX0912 QP; // Update to version 7.19 || June 05, 2010
	QP.UnlockKey(_T(QUICKPDF_LICENSE_KEY));
	lStr = CString("Quick PDF Library Version: ") + QP.LibraryVersion().c_str();
	SetDlgItemText(IDC_QPL_VERSION_STATIC, lStr);
	// ----------------------

	// Add the version number for sqlite
	// KDA: 09/06/2010
	SetDlgItemText(IDC_SQL_VERSION_STATIC, CString("SQLite Version: ") + CString(sqlite3_libversion()));

	m_DebenuURLBtn.SizeToContent();

	return TRUE;
}
Beispiel #8
0
// sqlite3 wrappers
__declspec(dllexport) const char * WINAPI sqlite3_libversion_interop(int *plen)
{
  const char *val = sqlite3_libversion();
  *plen = (val != 0) ? strlen(val) : 0;

  return val;
}
Beispiel #9
0
/* Don't call this function directly!  Use svn_atomic__init_once(). */
static svn_error_t *
init_sqlite(void *baton, apr_pool_t *pool)
{
  if (sqlite3_libversion_number() < SQLITE_VERSION_NUMBER) {
    return svn_error_createf(SVN_ERR_SQLITE_ERROR, NULL,
                             _("SQLite compiled for %s, but running with %s"),
                             SQLITE_VERSION, sqlite3_libversion());
  }

#if APR_HAS_THREADS
#if SQLITE_VERSION_AT_LEAST(3,5,0)
  /* SQLite 3.5 allows verification of its thread-safety at runtime.
     Older versions are simply expected to have been configured with
     --enable-threadsafe, which compiles with -DSQLITE_THREADSAFE=1
     (or -DTHREADSAFE, for older versions). */
  if (! sqlite3_threadsafe())
    return svn_error_create(SVN_ERR_SQLITE_ERROR, NULL,
                            _("SQLite is required to be compiled and run in "
                              "thread-safe mode"));
#endif
#if SQLITE_VERSION_AT_LEAST(3,6,0)
  /* If SQLite has been already initialized, sqlite3_config() returns
     SQLITE_MISUSE. */
  {
    int err = sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
    if (err != SQLITE_OK && err != SQLITE_MISUSE)
      return svn_error_create(SQLITE_ERROR_CODE(err), NULL,
                              "Could not configure SQLite");
  }
  SQLITE_ERR_MSG(sqlite3_initialize(), "Could not initialize SQLite");
#endif
#endif /* APR_HAS_THRADS */

  return SVN_NO_ERROR;
}
Beispiel #10
0
int proxy_db_init(pool *p) {
  const char *version;

  if (p == NULL) {
    errno = EINVAL;
    return -1;
  }

  if (db_pool != NULL) {
    return 0;
  }

  /* Check that the SQLite headers used match the version of the SQLite
   * library used.
   *
   * For now, we only log if there is a difference.
   */
  version = sqlite3_libversion();
  if (strcmp(version, SQLITE_VERSION) != 0) {
    (void) pr_log_writefile(proxy_logfd, MOD_PROXY_VERSION,
      "compiled using SQLite version '%s' headers, but linked to "
      "SQLite version '%s' library", SQLITE_VERSION, version);
  }

  pr_trace_msg(trace_channel, 9, "using SQLite %s", version);

  db_pool = make_sub_pool(p);
  pr_pool_tag(db_pool, "Proxy Database Pool");
  
  return 0;
}
Beispiel #11
0
int print_version(void)
{
	printf("%s %s (%s)\n", progname, SUUID_VERSION, SUUID_DATE);
#ifndef NO_SQLITE
	printf("Linked against SQLite %s\n", sqlite3_libversion());
#endif
#if defined(FAKE_HOST) || defined(TEST_FUNC)
	printf("\nThis version is compiled with the following conditional "
               "directives:\n");
#endif
#ifdef FAKE_HOST
	printf("\nFAKE_HOST: Always return \"fake\" as hostname. This is to "
	       "make sure it \n"
	       "doesn't write to the real log file.\n");
#endif
#ifdef TEST_FUNC
	printf("\nTEST_FUNC: Send non-option command line arguments to "
	       "various functions \n"
	       "for testing. This doesn't break anything, as the program only "
	       "checks for \n"
	       "options. Non-option arguments are ignored.\n");
#endif

	return EXIT_SUCCESS;
}
Beispiel #12
0
void print_version(const std::string& pgmname)
{
    std::cout
        << pgmname << " v0.0.0 - blah blah" << std::endl
        << "SQLite version " << sqlite3_libversion() << std::endl
        << "SQLite source ID " << sqlite3_sourceid() << std::endl;
    std::exit(EXIT_SUCCESS);
}
Beispiel #13
0
PCSTR
SqlVersion(
	VOID
	)
{
	PCSTR Version;
	Version = sqlite3_libversion();
	return Version;
}
Beispiel #14
0
/*
** Implementation of the sqlite_version() function.  The result is the version
** of the SQLite library that is running.
*/
static void versionFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **NotUsed2
){
  UNUSED_PARAMETER2(NotUsed, NotUsed2);
  /* IMP: R-48699-48617 This function is an SQL wrapper around the
  ** sqlite3_libversion() C-interface. */
  sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
}
SWIGEXPORT jstring JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1libversion(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (char *)sqlite3_libversion();
  if (result) jresult = (*jenv)->NewStringUTF(jenv, (const char *)result);
  return jresult;
}
Beispiel #16
0
void
sqlite_version_report(FILE *f)
{
fprintf(f, "Library version: SQLite: Compile: %s\n"
           "                         Runtime: %s\n",
        SQLITE_VERSION, sqlite3_libversion());
#ifdef DYNLOOKUP
fprintf(f, "                         Exim version %s\n", EXIM_VERSION_STR);
#endif
}
Beispiel #17
0
TEST(Versions, SQLite)
{
  // http://www.sqlite.org/capi3ref.html#sqlite3_libversion
  assert(sqlite3_libversion_number() == SQLITE_VERSION_NUMBER );
  assert(strcmp(sqlite3_sourceid(), SQLITE_SOURCE_ID) == 0);
  assert(strcmp(sqlite3_libversion(), SQLITE_VERSION) == 0);

  // Ensure that the SQLite version is above 3.7.0.
  // "sqlite3_create_function_v2" is not defined in previous versions.
  ASSERT_GE(SQLITE_VERSION_NUMBER, 3007000);
}
Beispiel #18
0
/*
Displays some pieces of version information which might be useful.
*/
int doVersion(){
	printf(
		"App Version:    %s\n"
		"DB Version:     %d\n"
		"SQLite Version: %s\n",
		VERSION,
		getDbVersion(),
		sqlite3_libversion());

    return SUCCESS;
}
Beispiel #19
0
int PDOSqliteConnection::getAttribute(int64_t attr, Variant &value) {
  switch (attr) {
  case PDO_ATTR_CLIENT_VERSION:
  case PDO_ATTR_SERVER_VERSION:
    value = String((char *)sqlite3_libversion(), CopyString);
    return true;
  default:
    return false;
  }
  return true;
}
Beispiel #20
0
static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, zend_long attr, zval *return_value)
{
	switch (attr) {
		case PDO_ATTR_CLIENT_VERSION:
		case PDO_ATTR_SERVER_VERSION:
			ZVAL_STRING(return_value, (char *)sqlite3_libversion());
			break;

		default:
			return 0;
	}

	return 1;
}
int main(void) {
    /* Determina l'opzione di configurazione relativa al multithreading, che
    non necessita peraltro di ulteriore argomento */
    sqlite3_config(SQLITE_CONFIG_MULTITHREAD);

    // Inizializzazione della libreria
    if (sqlite3_initialize() == SQLITE_OK)
        printf("Library: \'%s\' initialized\n", sqlite3_libversion());

    // Rilascio delle risorse
    if (sqlite3_shutdown() == SQLITE_OK)
        printf("Library: freed\n");

    return(EXIT_SUCCESS);
}
Beispiel #22
0
int main(int argc , char * argv[])
{
	int status;
	char * str_err_msg= NULL;
	db_report = stdout;
	printf("sqlite version : %s\n%s\n",sqlite3_libversion(),sqlite3_sourceid());
	//_hdb db;
	connect_db("demo.db");
	//	/**
	PREPARE("create table usrpwd(usr QString, pwd QString)");
	status = sqlite3_exec(db,
				QUERY,
				0,
				0,
				&str_err_msg);
	printf("c->status: %d ~ %s \n",status,str_err_msg);
	/* */
	// /**
	PREPARE("insert into usrpwd values('hkkk','khhh')");
	status = sqlite3_exec(db,
				QUERY,
				0,
				0,
				&str_err_msg);
	printf("c->status: %d ~ %s \n",status,str_err_msg);
	//**/

	PREPARE("select * from usrpwd ");

	status = sqlite3_exec(db,
	QUERY,
	result_handle, // int (*callback)(void*,int,char**,char**),
	0,
	&str_err_msg);
	printf("c->status: %d ~ %s \n",status,str_err_msg);



	status = sqlite3_close(db);
	if(status != SQLITE_OK )
	printf("error:%d\n",sqlite3_errcode(db));
	
	printf("%s",sqlite3_mprintf("%q","it's example"));
	return 0;
}
Beispiel #23
0
wxString GetDependencyVersion(dependency::type d)
{
	switch (d) {
	case dependency::wxwidgets:
		return wxVERSION_NUM_DOT_STRING_T;
	case dependency::gnutls:
		{
			const char* v = gnutls_check_version(0);
			if (!v || !*v)
				return _T("unknown");

			return wxString(v, wxConvLibc);
		}
	case dependency::sqlite:
		return wxString::FromUTF8(sqlite3_libversion());
	default:
		return wxString();
	}
}
SpatialiteBackend::SpatialiteBackend()
    : SpatialiteBase(), p(new SpatialBackendPrivate)
{
    /*
    VERY IMPORTANT:
    you must initialize the SpatiaLite extension [and related]
    BEFORE attempting to perform any other SQLite call
    */
    spatialite_init (0);

    /* showing the SQLite version */
    qDebug ("SQLite version: %s", sqlite3_libversion ());
    /* showing the SpatiaLite version */
    qDebug ("SpatiaLite version: %s", spatialite_version ());

    isTemp = true;
    theFilename = HOMEDIR + "/" + QDateTime::currentDateTime().toString("yyyyMMdd-hhmmsszzz") + ".spatialite";
    open(HOMEDIR + "/temDb.spatialite", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
    InitializeNew();
}
SpatialiteBackend::SpatialiteBackend(const QString& filename)
    : SpatialiteBase(), p(new SpatialBackendPrivate)
{
    /*
    VERY IMPORTANT:
    you must initialize the SpatiaLite extension [and related]
    BEFORE attempting to perform any other SQLite call
    */
    spatialite_init (0);

    /* showing the SQLite version */
    qDebug ("SQLite version: %s", sqlite3_libversion ());
    /* showing the SpatiaLite version */
    qDebug ("SpatiaLite version: %s", spatialite_version ());

    isTemp = false;
    theFilename = filename;
    open(theFilename, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
    InitializeNew();
}
Beispiel #26
0
SqliteDriver::SqliteDriver(QObject *parent, const QVariantList &args)
    : KDbDriver(parent, args)
    , dp(new SqliteDriverPrivate)
{
    beh->features = SingleTransactions | CursorForward | CompactingDatabaseSupported;

    //special method for autoincrement definition
    beh->SPECIAL_AUTO_INCREMENT_DEF = true;
    beh->AUTO_INCREMENT_FIELD_OPTION = QString(); //not available
    beh->AUTO_INCREMENT_TYPE = QLatin1String("INTEGER");
    beh->AUTO_INCREMENT_PK_FIELD_OPTION = QLatin1String("PRIMARY KEY");
    beh->AUTO_INCREMENT_REQUIRES_PK = true;
    beh->ROW_ID_FIELD_NAME = QLatin1String("OID");
    beh->IS_DB_OPEN_AFTER_CREATE = true;
    beh->_1ST_ROW_READ_AHEAD_REQUIRED_TO_KNOW_IF_THE_RESULT_IS_EMPTY = true;
    beh->QUOTATION_MARKS_FOR_IDENTIFIER = '"';
    beh->SELECT_1_SUBQUERY_SUPPORTED = true;
    beh->CONNECTION_REQUIRED_TO_CHECK_DB_EXISTENCE = false;
    beh->CONNECTION_REQUIRED_TO_CREATE_DB = false;
    beh->CONNECTION_REQUIRED_TO_DROP_DB = false;

    initDriverSpecificKeywords(keywords);

    // internal properties
    beh->properties.insert("client_library_version", QLatin1String(sqlite3_libversion()));
    beh->properties.insert("default_server_encoding", QLatin1String("UTF8")); //OK?

    beh->typeNames[KDbField::Byte] = QLatin1String("Byte");
    beh->typeNames[KDbField::ShortInteger] = QLatin1String("ShortInteger");
    beh->typeNames[KDbField::Integer] = QLatin1String("Integer");
    beh->typeNames[KDbField::BigInteger] = QLatin1String("BigInteger");
    beh->typeNames[KDbField::Boolean] = QLatin1String("Boolean");
    beh->typeNames[KDbField::Date] = QLatin1String("Date"); // In fact date/time types could be declared as datetext etc.
    beh->typeNames[KDbField::DateTime] = QLatin1String("DateTime"); // to force text affinity..., see http://sqlite.org/datatype3.html
    beh->typeNames[KDbField::Time] = QLatin1String("Time");
    beh->typeNames[KDbField::Float] = QLatin1String("Float");
    beh->typeNames[KDbField::Double] = QLatin1String("Double");
    beh->typeNames[KDbField::Text] = QLatin1String("Text");
    beh->typeNames[KDbField::LongText] = QLatin1String("CLOB");
    beh->typeNames[KDbField::BLOB] = QLatin1String("BLOB");
}
Beispiel #27
0
Datei: main.c Projekt: Tilka/ncdc
char *ncdc_version() {
  static GString *ver = NULL;
  static char *msg =
    "%s %s (built %s %s)\n"
    "Sendfile support: "
#ifdef HAVE_SENDFILE
     "yes (%s)\n"
#else
     "no\n"
#endif
    "Libraries:\n"
    "  GLib %d.%d.%d (%d.%d.%d)\n"
    "  GnuTLS %s (%s)\n"
    "  SQLite %s (%s)"
#ifdef NCURSES_VERSION
    "\n  ncurses %s"
#endif
  ;
  if(ver)
    return ver->str;
  ver = g_string_new("");
  g_string_printf(ver, msg, PACKAGE_NAME, main_version,
    __DATE__, __TIME__,
#ifdef HAVE_LINUX_SENDFILE
    "Linux",
#elif HAVE_BSD_SENDFILE
    "BSD",
#endif
    GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION, glib_major_version, glib_minor_version, glib_micro_version,
    GNUTLS_VERSION, gnutls_check_version(NULL),
    SQLITE_VERSION, sqlite3_libversion()
#ifdef NCURSES_VERSION
    , NCURSES_VERSION
#endif
  );
  return ver->str;
}
Beispiel #28
0
PyMODINIT_FUNC init_sqlightning(void)
{
    PyObject *module, *dict;
    PyObject *tmp_obj;
    int i;

    module = Py_InitModule("pysqlightning._sqlightning", module_methods);

    if (!module ||
        (pysqlite_row_setup_types() < 0) ||
        (pysqlite_cursor_setup_types() < 0) ||
        (pysqlite_connection_setup_types() < 0) ||
        (pysqlite_cache_setup_types() < 0) ||
        (pysqlite_statement_setup_types() < 0) ||
        #ifdef PYSQLITE_EXPERIMENTAL
        (pysqlite_backup_setup_types() < 0) ||
        #endif
        (pysqlite_prepare_protocol_setup_types() < 0)
       ) {
        return;
    }

    Py_INCREF(&pysqlite_ConnectionType);
    PyModule_AddObject(module, "Connection", (PyObject*) &pysqlite_ConnectionType);
    Py_INCREF(&pysqlite_CursorType);
    PyModule_AddObject(module, "Cursor", (PyObject*) &pysqlite_CursorType);
    Py_INCREF(&pysqlite_CacheType);
    PyModule_AddObject(module, "Statement", (PyObject*)&pysqlite_StatementType);
    Py_INCREF(&pysqlite_StatementType);
    PyModule_AddObject(module, "Cache", (PyObject*) &pysqlite_CacheType);
    Py_INCREF(&pysqlite_PrepareProtocolType);
    PyModule_AddObject(module, "PrepareProtocol", (PyObject*) &pysqlite_PrepareProtocolType);
    Py_INCREF(&pysqlite_RowType);
    PyModule_AddObject(module, "Row", (PyObject*) &pysqlite_RowType);

    if (!(dict = PyModule_GetDict(module))) {
        goto error;
    }

    /*** Create DB-API Exception hierarchy */

    if (!(pysqlite_Error = PyErr_NewException(MODULE_NAME ".Error", PyExc_StandardError, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "Error", pysqlite_Error);

    if (!(pysqlite_Warning = PyErr_NewException(MODULE_NAME ".Warning", PyExc_StandardError, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "Warning", pysqlite_Warning);

    /* Error subclasses */

    if (!(pysqlite_InterfaceError = PyErr_NewException(MODULE_NAME ".InterfaceError", pysqlite_Error, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "InterfaceError", pysqlite_InterfaceError);

    if (!(pysqlite_DatabaseError = PyErr_NewException(MODULE_NAME ".DatabaseError", pysqlite_Error, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "DatabaseError", pysqlite_DatabaseError);

    /* pysqlite_DatabaseError subclasses */

    if (!(pysqlite_InternalError = PyErr_NewException(MODULE_NAME ".InternalError", pysqlite_DatabaseError, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "InternalError", pysqlite_InternalError);

    if (!(pysqlite_OperationalError = PyErr_NewException(MODULE_NAME ".OperationalError", pysqlite_DatabaseError, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "OperationalError", pysqlite_OperationalError);

    if (!(pysqlite_ProgrammingError = PyErr_NewException(MODULE_NAME ".ProgrammingError", pysqlite_DatabaseError, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "ProgrammingError", pysqlite_ProgrammingError);

    if (!(pysqlite_IntegrityError = PyErr_NewException(MODULE_NAME ".IntegrityError", pysqlite_DatabaseError,NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "IntegrityError", pysqlite_IntegrityError);

    if (!(pysqlite_DataError = PyErr_NewException(MODULE_NAME ".DataError", pysqlite_DatabaseError, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "DataError", pysqlite_DataError);

    if (!(pysqlite_NotSupportedError = PyErr_NewException(MODULE_NAME ".NotSupportedError", pysqlite_DatabaseError, NULL))) {
        goto error;
    }
    PyDict_SetItemString(dict, "NotSupportedError", pysqlite_NotSupportedError);

    /* We just need "something" unique for pysqlite_OptimizedUnicode. It does not really
     * need to be a string subclass. Just anything that can act as a special
     * marker for us. So I pulled PyCell_Type out of my magic hat.
     */
    Py_INCREF((PyObject*)&PyCell_Type);
    pysqlite_OptimizedUnicode = (PyObject*)&PyCell_Type;
    PyDict_SetItemString(dict, "OptimizedUnicode", pysqlite_OptimizedUnicode);

    /* Set integer constants */
    for (i = 0; _int_constants[i].constant_name != 0; i++) {
        tmp_obj = PyInt_FromLong(_int_constants[i].constant_value);
        if (!tmp_obj) {
            goto error;
        }
        PyDict_SetItemString(dict, _int_constants[i].constant_name, tmp_obj);
        Py_DECREF(tmp_obj);
    }

    if (!(tmp_obj = PyString_FromString(PYSQLITE_VERSION))) {
        goto error;
    }
    PyDict_SetItemString(dict, "version", tmp_obj);
    Py_DECREF(tmp_obj);

    if (!(tmp_obj = PyString_FromString(sqlite3_libversion()))) {
        goto error;
    }
    PyDict_SetItemString(dict, "sqlite_version", tmp_obj);
    Py_DECREF(tmp_obj);

    /* initialize microprotocols layer */
    pysqlite_microprotocols_init(dict);

    /* initialize the default converters */
    converters_init(dict);

    _enable_callback_tracebacks = 0;

    pysqlite_BaseTypeAdapted = 0;

    /* Original comment from _bsddb.c in the Python core. This is also still
     * needed nowadays for Python 2.3/2.4.
     * 
     * PyEval_InitThreads is called here due to a quirk in python 1.5
     * - 2.2.1 (at least) according to Russell Williamson <*****@*****.**>:
     * The global interpreter lock is not initialized until the first
     * thread is created using thread.start_new_thread() or fork() is
     * called.  that would cause the ALLOW_THREADS here to segfault due
     * to a null pointer reference if no threads or child processes
     * have been created.  This works around that and is a no-op if
     * threads have already been initialized.
     *  (see pybsddb-users mailing list post on 2002-08-07)
     */
#ifdef WITH_THREAD
    PyEval_InitThreads();
#endif

error:
    if (PyErr_Occurred())
    {
        PyErr_SetString(PyExc_ImportError, "pysqlightning._sqlightning: init failed");
    }
}
Beispiel #29
0
static void bug_information_generate_message(GtkTextBuffer * buffer)
{
	int i;
	gchar *temp;
	GtkTextIter iter;
	GtkTextTag *bold_tag, *larger_tag;
	GtkTextTagTable *table;

	/* get buffer's tag table */
	table = gtk_text_buffer_get_tag_table(buffer);
	/* Create bold tag */
	bold_tag = gtk_text_tag_new("bold");
	g_object_set(G_OBJECT(bold_tag), "weight", PANGO_WEIGHT_BOLD, NULL);
	/* add bold_tag to tag table */
	gtk_text_tag_table_add(table, bold_tag);

	/* Create bold tag */
	larger_tag = gtk_text_tag_new("larger");
	g_object_set(G_OBJECT(larger_tag), "scale", PANGO_SCALE_X_LARGE, NULL);
	/* add larger_tag to tag table */
	gtk_text_tag_table_add(table, larger_tag);

	/* Get the start */
	gtk_text_buffer_get_start_iter(buffer, &iter);

	/* insert program name */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Gnome Music Player Client\n", -1, bold_tag, larger_tag, NULL);
	/* insert copyright */
	gtk_text_buffer_insert_with_tags(buffer, &iter, GMPC_COPYRIGHT "\n\n", -1, bold_tag, NULL);

	/* insert tagline */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Tagline:\t", -1, bold_tag, NULL);
	gtk_text_buffer_insert(buffer, &iter, GMPC_TAGLINE "\n", -1);

	/* insert version */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Version:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%i.%i.%i\n", GMPC_MAJOR_VERSION, GMPC_MINOR_VERSION, GMPC_MICRO_VERSION);
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);

	/* insert revision */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Revision:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%s\n", revision);
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);

	/** support libs */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nSupport libraries:\n", -1, bold_tag, larger_tag, NULL);

	/* libmpd */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Libmpd:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%i.%i.%i\n", LIBMPD_MAJOR_VERSION, LIBMPD_MINOR_VERSION, LIBMPD_MICRO_VERSION);
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);

	/* gtk+-2.0 */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Compile time Gtk+-2.0:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%i.%i.%i\n", GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);

	gtk_text_buffer_insert_with_tags(buffer, &iter, "Runtime Gtk+-2.0:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%i.%i.%i\n", gtk_major_version, gtk_minor_version, gtk_micro_version);
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);

	/* glib-2.0 */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Glib-2.0:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%i.%i.%i\n", GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);

	/* glib-2.0 */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Runtime sqlite3:\t", -1, bold_tag, NULL);
	gtk_text_buffer_insert(buffer, &iter, sqlite3_libversion(), -1);

	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nCompile time sqlite3:\t", -1, bold_tag, NULL);
	gtk_text_buffer_insert(buffer, &iter, SQLITE_VERSION, -1);

#ifdef HAVE_UNIQUE
	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nLibunique:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%s\n", UNIQUE_VERSION_S);
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);
#endif	
	/* platform */
	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nPlatform:\t", -1, bold_tag, NULL);
#ifdef WIN32
	gtk_text_buffer_insert(buffer, &iter, "Windows\n", -1);
	gtk_text_buffer_insert_with_tags(buffer, &iter, "Windows version:\t", -1, bold_tag, NULL);
	temp = g_strdup_printf("%i\n", g_win32_get_windows_version());
	gtk_text_buffer_insert(buffer, &iter, temp, -1);
	g_free(temp);
#else
#ifdef OSX
	gtk_text_buffer_insert(buffer, &iter, "Mac OsX\n", -1);
#else
	gtk_text_buffer_insert(buffer, &iter, "*nix\n", -1);
#endif
#endif

	/** compile flags*/
	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nCompile flags:\n", -1, bold_tag, larger_tag, NULL);

	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nNLS Support:\t", -1, bold_tag, NULL);
#ifdef ENABLE_NLS
	gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
	gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif

	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nMultimedia Keys:\t", -1, bold_tag, NULL);
#ifdef ENABLE_MMKEYS
	gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
	gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif

    gtk_text_buffer_insert_with_tags(buffer, &iter, "\nAppIndicator Support:\t", -1, bold_tag, NULL);
#ifdef HAVE_APP_INDICATOR
    gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
    gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif

	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nLibspiff support:\t", -1, bold_tag, NULL);
#ifdef SPIFF
	gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
	gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif

	gtk_text_buffer_insert_with_tags(buffer, &iter, "\nLibunique support:\t", -1, bold_tag, NULL);
#ifdef HAVE_UNIQUE
	gtk_text_buffer_insert(buffer, &iter, "Enabled", -1);
#else
	gtk_text_buffer_insert(buffer, &iter, "Disabled", -1);
#endif

	/** Plugins */
	if (num_plugins > 0)
	{
		gtk_text_buffer_insert_with_tags(buffer, &iter, "\n\nExternal Plugins:\n", -1, bold_tag, larger_tag, NULL);
		for (i = 0; i < num_plugins; i++)
		{
			if (!gmpc_plugin_is_internal(plugins[i]))
			{
				const gchar *name = gmpc_plugin_get_name(plugins[i]);
				const int *version = gmpc_plugin_get_version(plugins[i]);
				if(gmpc_plugin_get_enabled(plugins[i])) {
					gtk_text_buffer_insert(buffer, &iter, "☑ ", -1);
				}else  {
					gtk_text_buffer_insert(buffer, &iter, "☐ ", -1);
				}
				gtk_text_buffer_insert_with_tags(buffer, &iter, name, -1, bold_tag, NULL);
				temp = g_strdup_printf("\t%i.%i.%i\n", version[0], version[1], version[2]);
				gtk_text_buffer_insert(buffer, &iter, temp, -1);
				g_free(temp);
			}
		}
	}
	if (num_plugins > 0)
	{
		gtk_text_buffer_insert_with_tags(buffer, &iter, "\n\nMetadata Plugins:\n", -1, bold_tag, larger_tag, NULL);
		for (i = 0; i < num_plugins; i++)
		{
			if (gmpc_plugin_is_metadata(plugins[i]))
			{
				const gchar *name = gmpc_plugin_get_name(plugins[i]);
				const int *version = gmpc_plugin_get_version(plugins[i]);
				if(gmpc_plugin_get_enabled(plugins[i])) {
					gtk_text_buffer_insert(buffer, &iter, "☑ ", -1);
				}else  {
					gtk_text_buffer_insert(buffer, &iter, "☐ ", -1);
				}
				gtk_text_buffer_insert_with_tags(buffer, &iter, name, -1, bold_tag, NULL);
				temp = g_strdup_printf("\t%i.%i.%i\n", version[0], version[1], version[2]);
				gtk_text_buffer_insert(buffer, &iter, temp, -1);
				g_free(temp);
			}
		}
	}

	if (mpd_check_connected(connection))
	{
		gchar **handlers;
		/** Plugins */
		gtk_text_buffer_insert_with_tags(buffer, &iter, "\nMusic Player Daemon:\n", -1, bold_tag, larger_tag, NULL);

		/* Version */
		gtk_text_buffer_insert_with_tags(buffer, &iter, "Version:\t", -1, bold_tag, NULL);
		temp = mpd_server_get_version(connection);
		gtk_text_buffer_insert(buffer, &iter, temp, -1);
		g_free(temp);

		/* total songs */
		gtk_text_buffer_insert_with_tags(buffer, &iter, "\nSongs:\t", -1, bold_tag, NULL);
		temp = g_strdup_printf("%i", mpd_stats_get_total_songs(connection));
		gtk_text_buffer_insert(buffer, &iter, temp, -1);
		g_free(temp);

		/* hostname */
		gtk_text_buffer_insert_with_tags(buffer, &iter, "\nHostname:\t", -1, bold_tag, NULL);
		temp = connection_get_hostname();
		gtk_text_buffer_insert(buffer, &iter, temp, -1);
		/* handlers */
		gtk_text_buffer_insert_with_tags(buffer, &iter, "\nUrl handlers:\t", -1, bold_tag, NULL);
		handlers = mpd_server_get_url_handlers(connection);
		if (handlers)
		{
			temp = g_strjoinv(",", handlers);
			g_strfreev(handlers);
			handlers = NULL;
		} else
			temp = g_strdup("N/A");
		gtk_text_buffer_insert(buffer, &iter, temp, -1);
		g_free(temp);

	}
}
Beispiel #30
0
int
main (int argc, char *argv[])
{
    int ret;
    sqlite3 *handle;
    sqlite3_stmt *stmt;
    gaiaGeomCollPtr geom;
    char sql[256];
    int i;
    int ic;
    char **results;
    int n_rows;
    int n_columns;
    char *err_msg = NULL;
    int len;
    char *table_name;
    char **p_geotables = NULL;
    int n_geotables = 0;
    int row_no;
    const void *blob;
    int blob_size;
    int geom_type;
    double measure;
    void *cache;


    if (argc != 2)
      {
	  fprintf (stderr, "usage: %s test_db_path\n", argv[0]);
	  return -1;
      }


/* 
trying to connect the test DB: 
- this demo was designed in order to connect the standard 
  TEST-2.3.SQLITE sample DB
- but you can try to use any SQLite/SpatiaLite DB at your will

Please notice: we'll establish a READ ONLY connection 
*/
    ret = sqlite3_open_v2 (argv[1], &handle, SQLITE_OPEN_READONLY, NULL);
    if (ret != SQLITE_OK)
      {
	  printf ("cannot open '%s': %s\n", argv[1], sqlite3_errmsg (handle));
	  sqlite3_close (handle);
	  return -1;
      }

/* 
VERY IMPORTANT: 
you must initialize the SpatiaLite extension [and related]
BEFORE attempting to perform any other SQLite call 
==========================================================
Please note: starting since 4.1.0 this is completely canged:
- a separate memory block (internal cache) is required by
  each single connection
- allocating/freeing this block falls under the responsibility 
  of the program handling the connection
- in multithreaded programs a connection can never be share by
  different threads; the internal-cache block must be allocated
  by the same thread holding the connection
*/
    
    cache = spatialite_alloc_connection ();
    spatialite_init_ex (handle, cache, 0);


/* showing the SQLite version */
    printf ("SQLite version: %s\n", sqlite3_libversion ());
/* showing the SpatiaLite version */
    printf ("SpatiaLite version: %s\n", spatialite_version ());
    printf ("\n\n");



/* 
SQL query #1 
we'll retrieve GEOMETRY tables from Spatial Metadata 
we are assuming this query will return only few rows, 
so this time we'll use the sqlite3_get_table() interface

this interface is very simple to use
the result set is returned as a rectangular array [rows/columns]
allocated in a temporary memory storage
so, this interface is well suited for small sized result sets,
but performs badly when accessing a large sized resul set

as a side effect, each column value is returned as text, and
isn't possible at all to retrieve true column types
(INTEGER, FLOAT ...)
*/
    strcpy (sql,
	    "SELECT DISTINCT f_table_name FROM geometry_columns ORDER BY 1");
    ret = sqlite3_get_table (handle, sql, &results, &n_rows, &n_columns,
			     &err_msg);
    if (ret != SQLITE_OK)
      {
/* some error occurred */
	  printf ("query#1 SQL error: %s\n", err_msg);
	  sqlite3_free (err_msg);
	  goto abort;
      }
    if (n_rows > 1)
      {
/* first row always contains column names and is meaningless in this context */
	  n_geotables = n_rows;
/* allocating a dynamic pointer array to store geotable names */
	  p_geotables = malloc (sizeof (char *) * n_geotables);
	  for (i = 1; i <= n_rows; i++)
	    {
/* 
now we'll fetch one row at each time [and we have only one column to fetch] 

this one is is a simplified demo; but when writing a real application 
you always must check for NULL values !!!!
*/
		table_name = results[(i * n_columns) + 0];
/* and we'll store each geotable name into the dynamic pointer array */
		len = strlen (table_name);
		p_geotables[i - 1] = malloc (len + 1);
		strcpy (p_geotables[i - 1], table_name);
	    }
/* we can now free the table results */
	  sqlite3_free_table (results);
      }



    for (i = 0; i < n_geotables; i++)
      {
/* now we'll scan each geotable we've found in Spatial Metadata */
	  printf ("========= table '%s' ========================\n",
		  p_geotables[i]);



/*
SQL query #2 
we'll retrieve any column from the current geotable 
we are assuming this query will return lots of rows, 
so we have to use sqlite3_prepare_v2() interface

this interface is a more complex one, but is well
suited in order to access huge sized result sets
and true value type control is supported
*/
	  sprintf (sql, "SELECT * FROM %s", p_geotables[i]);
	  ret = sqlite3_prepare_v2 (handle, sql, strlen (sql), &stmt, NULL);
	  if (ret != SQLITE_OK)
	    {
/* some error occurred */
		printf ("query#2 SQL error: %s\n", sqlite3_errmsg (handle));
		goto abort;
	    }

/* 
the sqlite3_prepare_v2() call simply parses the SQL statement,
checking for syntax validity, allocating internal structs etc
but no result set row is really yet available
*/

/* we'll now save the #columns within the result set */
	  n_columns = sqlite3_column_count (stmt);
	  row_no = 0;


	  while (1)
	    {
/* this is an infinite loop, intended to fetch any row */

/* we are now trying to fetch the next available row */
		ret = sqlite3_step (stmt);
		if (ret == SQLITE_DONE)
		  {
/* there are no more rows to fetch - we can stop looping */
		      break;
		  }
		if (ret == SQLITE_ROW)
		  {
/* ok, we've just fetched a valid row to process */
		      row_no++;
		      printf ("row #%d\n", row_no);


		      for (ic = 0; ic < n_columns; ic++)
			{
/* 
and now we'll fetch column values

for each column we'll then get:
- the column name
- a column value, that can be of type: SQLITE_NULL, SQLITE_INTEGER, 
 SQLITE_FLOAT, SQLITE_TEXT or SQLITE_BLOB, according to internal DB storage type
*/
			    printf ("\t%-10s = ",
				    sqlite3_column_name (stmt, ic));
			    switch (sqlite3_column_type (stmt, ic))
			      {
			      case SQLITE_NULL:
				  printf ("NULL");
				  break;
			      case SQLITE_INTEGER:
				  printf ("%d", sqlite3_column_int (stmt, ic));
				  break;
			      case SQLITE_FLOAT:
				  printf ("%1.4f",
					  sqlite3_column_double (stmt, ic));
				  break;
			      case SQLITE_TEXT:
				  printf ("'%s'",
					  sqlite3_column_text (stmt, ic));
				  break;
			      case SQLITE_BLOB:
				  blob = sqlite3_column_blob (stmt, ic);
				  blob_size = sqlite3_column_bytes (stmt, ic);

/* checking if this BLOB actually is a GEOMETRY */
				  geom =
				      gaiaFromSpatiaLiteBlobWkb (blob,
								 blob_size);
				  if (!geom)
				    {
/* for sure this one is not a GEOMETRY */
					printf ("BLOB [%d bytes]", blob_size);
				    }
				  else
				    {
					geom_type = gaiaGeometryType (geom);
					if (geom_type == GAIA_UNKNOWN)
					    printf ("EMPTY or NULL GEOMETRY");
					else
					  {
					      char *geom_name;
					      if (geom_type == GAIA_POINT)
						  geom_name = "POINT";
					      if (geom_type == GAIA_LINESTRING)
						  geom_name = "LINESTRING";
					      if (geom_type == GAIA_POLYGON)
						  geom_name = "POLYGON";
					      if (geom_type == GAIA_MULTIPOINT)
						  geom_name = "MULTIPOINT";
					      if (geom_type ==
						  GAIA_MULTILINESTRING)
						  geom_name = "MULTILINESTRING";
					      if (geom_type ==
						  GAIA_MULTIPOLYGON)
						  geom_name = "MULTIPOLYGON";
					      if (geom_type ==
						  GAIA_GEOMETRYCOLLECTION)
						  geom_name =
						      "GEOMETRYCOLLECTION";
					      printf ("%s SRID=%d", geom_name,
						      geom->Srid);
					      if (geom_type == GAIA_LINESTRING
						  || geom_type ==
						  GAIA_MULTILINESTRING)
						{
#ifndef OMIT_GEOS		/* GEOS is required */
						    gaiaGeomCollLength (geom,
									&measure);
						    printf (" length=%1.2f",
							    measure);
#else
						    printf
							(" length=?? [no GEOS support available]");
#endif /* GEOS enabled/disabled */
						}
					      if (geom_type == GAIA_POLYGON ||
						  geom_type ==
						  GAIA_MULTIPOLYGON)
						{
#ifndef OMIT_GEOS		/* GEOS is required */
						    gaiaGeomCollArea (geom,
								      &measure);
						    printf (" area=%1.2f",
							    measure);
#else
						    printf
							("area=?? [no GEOS support available]");
#endif /* GEOS enabled/disabled */
						}
					  }
/* we have now to free the GEOMETRY */
					gaiaFreeGeomColl (geom);
				    }

				  break;
			      };
			    printf ("\n");
			}

		      if (row_no >= 5)
			{
/* we'll exit the loop after the first 5 rows - this is only a demo :-) */
			    break;
			}
		  }
		else
		  {
/* some unexpected error occurred */
		      printf ("sqlite3_step() error: %s\n",
			      sqlite3_errmsg (handle));
		      sqlite3_finalize (stmt);
		      goto abort;
		  }
	    }
/* we have now to finalize the query [memory cleanup] */
	  sqlite3_finalize (stmt);
	  printf ("\n\n");

      }



/* disconnecting the test DB */
    ret = sqlite3_close (handle);
    if (ret != SQLITE_OK)
      {
	  printf ("close() error: %s\n", sqlite3_errmsg (handle));
	  return -1;
      }

/* freeing the internal-cache memory block */
    spatialite_cleanup_ex (cache);

    printf ("\n\nsample successfully terminated\n");
/* we have to free the dynamic pointer array used to store geotable names */
    for (i = 0; i < n_geotables; i++)
      {
/* freeing each tablename */
	  free (p_geotables[i]);
      }
    free (p_geotables);
    spatialite_shutdown();
    return 0;

  abort:
    sqlite3_close (handle);

/* freeing the internal-cache memory block */
    spatialite_cleanup_ex (cache);

    if (p_geotables)
      {
/* we have to free the dynamic pointer array used to store geotable names */
	  for (i = 0; i < n_geotables; i++)
	    {
/* freeing each tablename */
		free (p_geotables[i]);
	    }
	  free (p_geotables);
      }
    spatialite_shutdown();
    return -1;
}