コード例 #1
0
ファイル: test2.c プロジェクト: lubing521/wifi-bus-app
int main(int argc, char*argv[]){
 
 ALGraph G;
 ALGraph* GPt = &G;
 initALGraph(GPt,1000);
 #if 0
 initALGraph(GPt,6);

 insertArc(GPt,0,1,7);
 
 insertArc(GPt,0,2,9);
 insertArc(GPt,0,5,14);
 insertArc(GPt,1,2,10);
 insertArc(GPt,1,3,15);
 insertArc(GPt,2,5,2);
 insertArc(GPt,2,3,10);
 insertArc(GPt,5,4,9);
 insertArc(GPt,3,4,6);
 insertArc(GPt,4,3,6);
#endif 
 #if 1
   sqlite3 *db;
    char *zErrMsg = 0;
    int rc, ret = 0, j,i, row_count = 0;
    printf("sqlite3 info:\n libversion:%s\n souceid:%s\n vesion_num:%d\n",sqlite3_libversion(), sqlite3_sourceid(),
      sqlite3_libversion_number());
  sqlite3_stmt *pStmt = NULL;
  
    if( argc < 3 ){
      fprintf(stderr, "Usage: %s DATABASE SQL-STATEMENT\n", argv[0]);
      return(1);
    }
    rc = sqlite3_open(argv[1], &db);
    if( rc ){
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      sqlite3_close(db);
      return(1);
    }

    rc = sqlite3_prepare(db, argv[2], strlen(argv[2]), &pStmt, NULL);
    printf("rc =%d\n", rc);
  if(rc != SQLITE_OK){
    fprintf(stderr, "SQL error1: %s\n", zErrMsg);
    sqlite3_free(zErrMsg);
    return 1;
  }
  
  printf("pStmt=%p\n",pStmt);
  ret = sqlite3_column_count(pStmt);
  printf("BEFORE STEP col count= %d, rc = %d\n", ret, rc);
   printf("pStmt22=%p\n",pStmt);
  i = 0;
  //´òÓ¡colÃû³Æ
  while(i < ret){
    printf("%20s \t %d \t %20s \t %d\n",
      sqlite3_column_name(pStmt, i),
      sqlite3_column_type(pStmt, i),
      sqlite3_column_decltype(pStmt, i),
      sqlite3_column_bytes(pStmt, i));
    i++;
  }
  printf("pStmt23=%p\n",pStmt);
 

 
  printf("\n------ ------ ------ ------ ------------ ------ ------ ------\n");
  printf("pStmt2=%p\n",pStmt);
  rc = sqlite3_step(pStmt);
   printf("pStmt3=%p\n",pStmt);
    STRACE
  if(rc != SQLITE_ROW){
          fprintf(stderr, "SQL error2: %s,rc =%d\n", zErrMsg, rc);
          sqlite3_free(zErrMsg);
    return 1;
  }
  STRACE
  //¿ªÊ¼¶ÁȡÿһÐÐ
  while(rc == SQLITE_ROW){
    //STRACE
    i = 0;row_count++;
    // for(j=0;j< ret;j++){
    //   printf("%s ", sqlite3_column_text(pStmt,j));
    // }
    //printf("%d -> %d w:%d\n", sqlite3_column_int(pStmt,1), sqlite3_column_int(pStmt,2), sqlite3_column_int(pStmt,4));
    insertArc(GPt,sqlite3_column_int(pStmt,1), sqlite3_column_int(pStmt,2), sqlite3_column_int(pStmt,4));
    #if 0
    printf("%d, %s, %s, %s\n",
      sqlite3_column_int(pStmt, 0),
      sqlite3_column_text(pStmt, 1),
      sqlite3_column_text(pStmt, 2),
      sqlite3_column_text(pStmt, 3));
    #endif
    rc = sqlite3_step(pStmt);
  }
  STRACE
  printf("row_count=%d\n ", row_count);
  sqlite3_finalize(pStmt);

    sqlite3_close(db);
#endif
 G.vexnum = row_count;
 printf("显示出此构造的图:\n");
 //displayGraph(G);
 printf("\n");
 
 int d[MAX_VERTEX_NUM];
 int pi[MAX_VERTEX_NUM];
 int Q[MAX_VERTEX_NUM+1]; 
        //Q[]的第一个元素只保存堆的大小,不保存元素。所以定义长度时+1

 dijkstra(G,1,d,pi,Q);
STRACE
    i= atoi(argv[3]);
    printf("从源点1到点%d的最短路径信息:\n",i);
    printf("长度为%d\n",d[i]);
    printf("路径为: %d ", i);
    for(j=i;j>1;){
     printf("%d ",pi[j]);
     j=pi[j];
    }
    printf("\n");

 // for(i=1;i<G.vexnum;i++){
  
 //  printf("从源点1到点%d的最短路径信息:\n",i);
 //  printf("长度为%d\n",d[i]);
 //  printf("路径为: %d ", i);
 //  for(j=i;j>0;){
 //  	printf("%d ",pi[j]);
 //  	j=pi[j];
 //  }
 
 //}
 return 0; 
}
コード例 #2
0
ファイル: emacsql.c プロジェクト: ananthakumaran/dotfiles
int main(int argc, char **argv) {
    char *file = NULL;
    if (argc != 2) {
        fprintf(stderr,
                "error: require exactly one argument, the DB filename\n");
        exit(EXIT_FAILURE);
    } else {
        file = argv[1];
    }

    /* On Windows stderr is not always unbuffered. */
#if defined(_WIN32) || defined(WIN32) || defined(__MINGW32__)
    setvbuf(stderr, NULL, _IONBF, 0);
#endif

    sqlite3* db = NULL;
    if (sqlite3_initialize() != SQLITE_OK) {
        fprintf(stderr, "error: failed to initialize sqlite\n");
        exit(EXIT_FAILURE);
    }
    int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
    if (sqlite3_open_v2(file, &db, flags, NULL) != SQLITE_OK) {
        fprintf(stderr, "error: failed to open %s\n", file);
        exit(EXIT_FAILURE);
    }

    buffer *input = buffer_create();
    while (TRUE) {
        printf("#\n");
        fflush(stdout);

        /* Gather input from Emacs. */
        unsigned length;
        int result = scanf("%u ", &length);
        if (result == EOF) {
            break;
        } else if (result != 1) {
            send_error(SQLITE_ERROR, "middleware parsing error");
            break;  /* stream out of sync: quit program */
        }
        if (!buffer_read(input, length)) {
            send_error(SQLITE_NOMEM, "middleware out of memory");
            continue;
        }

        /* Parse SQL statement. */
        sqlite3_stmt *stmt = NULL;
        result = sqlite3_prepare_v2(db, input->buffer, length, &stmt, NULL);
        if (result != SQLITE_OK) {
            send_error(sqlite3_errcode(db), sqlite3_errmsg(db));
            continue;
        }

        /* Print out rows. */
        int first = TRUE, ncolumns = sqlite3_column_count(stmt);
        printf("(");
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            if (first) {
                printf("(");
                first = FALSE;
            } else {
                printf("\n (");
            }
            int i;
            for (i = 0; i < ncolumns; i++) {
                if (i > 0) {
                    printf(" ");
                }
                int type = sqlite3_column_type(stmt, i);
                switch (type) {
                case SQLITE_INTEGER:
                    printf("%lld", sqlite3_column_int64(stmt, i));
                    break;
                case SQLITE_FLOAT:
                    printf("%f", sqlite3_column_double(stmt, i));
                    break;
                case SQLITE_NULL:
                    printf("nil");
                    break;
                case SQLITE_TEXT:
                    fwrite(sqlite3_column_text(stmt, i), 1,
                           sqlite3_column_bytes(stmt, i), stdout);
                    break;
                case SQLITE_BLOB:
                    printf("nil");
                    break;
                }
            }
            printf(")");
        }
        printf(")\n");
        if (sqlite3_finalize(stmt) != SQLITE_OK) {
            /* Despite any error code, the statement is still freed.
             * http://stackoverflow.com/a/8391872
             */
            send_error(sqlite3_errcode(db), sqlite3_errmsg(db));
        } else {
            printf("success\n");
        }
    }
    buffer_free(input);

    sqlite3_close(db);
    sqlite3_shutdown();
    return EXIT_SUCCESS;
}
コード例 #3
0
ファイル: db.c プロジェクト: brownvin81/proftpd-mod_proxy
array_header *proxy_db_exec_prepared_stmt(pool *p, const char *stmt,
    const char **errstr) {
  sqlite3_stmt *pstmt;
  int readonly = FALSE, res;
  array_header *results = NULL;

  if (p == NULL ||
      stmt == NULL) {
    errno = EINVAL;
    return NULL;
  }

  if (prepared_stmts == NULL) {
    errno = ENOENT;
    return NULL;
  }

  pstmt = pr_table_get(prepared_stmts, stmt, NULL);
  if (pstmt == NULL) {
    pr_trace_msg(trace_channel, 19,
      "unable to find prepared statement for '%s'", stmt);
    errno = ENOENT;
    return NULL;
  }

  readonly = sqlite3_stmt_readonly(pstmt);
  if (!readonly) {
    /* Assume this is an INSERT/UPDATE/DELETE. */
    res = sqlite3_step(pstmt);
    if (res != SQLITE_DONE) {
      const char *errmsg;

      errmsg = sqlite3_errmsg(proxy_dbh);
      if (errstr) {
        *errstr = pstrdup(p, errmsg);
      }
      pr_trace_msg(trace_channel, 2,
        "error executing '%s': %s", stmt, errmsg);
      errno = EPERM;
      return NULL;
    }

    /* Indicate success for non-readonly statements by returning an empty
     * result set.
     */
    pr_trace_msg(trace_channel, 13, "successfully executed '%s'", stmt);
    results = make_array(p, 0, sizeof(char *));
    return results;
  }

  results = make_array(p, 0, sizeof(char *));

  res = sqlite3_step(pstmt);
  while (res == SQLITE_ROW) {
    register unsigned int i;
    int ncols;

    ncols = sqlite3_column_count(pstmt);
    pr_trace_msg(trace_channel, 12,
      "executing prepared statement '%s' returned row (columns: %d)",
      stmt, ncols);

    for (i = 0; i < ncols; i++) {
      char *val = NULL;

      pr_signals_handle();

      /* By using sqlite3_column_text, SQLite will coerce the column value
       * into a string.
       */
      val = pstrdup(p, (const char *) sqlite3_column_text(pstmt, i));

      pr_trace_msg(trace_channel, 17,
        "column %s [%u]: %s", sqlite3_column_name(pstmt, i), i, val);
      *((char **) push_array(results)) = val;
    }

    res = sqlite3_step(pstmt);
  }

  if (res != SQLITE_DONE) {
    const char *errmsg;

    errmsg = sqlite3_errmsg(proxy_dbh);
    if (errstr != NULL) {
      *errstr = pstrdup(p, errmsg);
    }

    (void) pr_log_writefile(proxy_logfd, MOD_PROXY_VERSION,
      "executing prepared statement '%s' did not complete successfully: %s",
      stmt, errmsg);
    errno = EPERM;
    return NULL;
  }

  pr_trace_msg(trace_channel, 13, "successfully executed '%s'", stmt);
  return results;
}
コード例 #4
0
ファイル: group-sqlite.c プロジェクト: A1izee/range
range* rangefunc_group(range_request* rr, range** r)
{
    range* ret;
    const char** members;
    int i, err;
    sqlite3* db;
    sqlite3_stmt* tag_stmt;
    sqlite3_stmt* all_nodes_stmt;
    apr_pool_t* pool = range_request_pool(rr);
    libcrange* lr = range_request_lr(rr);
    
    ret = range_new(rr);
    members = range_get_hostnames(pool, r[0]);

    if (!(db = libcrange_get_cache(lr, "sqlite:nodes"))) {
	const char* sqlite_db_path = libcrange_getcfg(lr, "sqlitedb");
	if (!sqlite_db_path) sqlite_db_path = DEFAULT_SQLITE_DB;

	err = sqlite3_open(sqlite_db_path, &db);
	if (err != SQLITE_OK) {
	    fprintf(stderr, "%s: %s\n", sqlite_db_path, sqlite3_errmsg(db));
	    return ret;
	}

	libcrange_set_cache(lr, "sqlite:nodes", db);
    }


    /* prepare our selects */
    err = sqlite3_prepare(db, ALL_NODES_SQL, strlen(ALL_NODES_SQL),
                          &all_nodes_stmt, NULL);
    if (err != SQLITE_OK) {
        fprintf(stderr, "%s: %s\n", ALL_NODES_SQL, sqlite3_errmsg(db));
        abort();
    }

    err = sqlite3_prepare(db, RANGE_FROM_TAGS, strlen(RANGE_FROM_TAGS),
                          &tag_stmt, NULL);
    assert(err == SQLITE_OK);

    /* for each group */
    for (i = 0; members[i]; ++i) {
        sqlite3_stmt* stmt;
        if (strcmp(members[i], "ALL") == 0) {
            stmt = all_nodes_stmt;
        } else {
            stmt = tag_stmt;
            /* bind the current group name */
            sqlite3_bind_text(tag_stmt, 1, members[i], strlen(members[i]), SQLITE_STATIC);
        }

        while (sqlite3_step(stmt) == SQLITE_ROW) {
            range* this_group;
            const char* result = (const char*)sqlite3_column_text(stmt, 0);
            if (stmt == all_nodes_stmt) {
                range_add(ret, result);
            } else {
                this_group = do_range_expand(rr, result);
                set_union_inplace(ret->nodes, this_group->nodes);
            }
        }
        sqlite3_reset(stmt);
    }
    sqlite3_finalize(all_nodes_stmt);
    sqlite3_finalize(tag_stmt);

    return ret;
}
コード例 #5
0
ファイル: box_conf_change.c プロジェクト: WangZzzz/box_rs
int main()
{
	printf("\n********************************\n");
	printf("box_conf_change : start\n");
	printf("********************************\n");
		
	char url[1024] = {0};
	ghttp_request *req;
	char http_body[1024] = {0};

	sqlite3 *db = NULL;
    sqlite3_stmt *ppstmt = NULL;
    int rc = 0;
    char sql_cmd[100] = {0};
	char *errorMsg = NULL;
	const char *box_id = NULL;
    char box_id_tmp[10] = {0};
	int db_cnt = 0;

	while(db_cnt < 20)
	{
		rc = sqlite3_open(box_db, &db);
		if(rc == SQLITE_ERROR)
            printf("open box.db failed");

        ppstmt = NULL;
        memset(sql_cmd, 0, sizeof(sql_cmd));
        strcpy(sql_cmd, "select box_id from box_info");
        sqlite3_prepare(db, sql_cmd, -1, &ppstmt, 0);
        rc = sqlite3_step(ppstmt);
        if(rc == SQLITE_ROW)
        {
            box_id = sqlite3_column_text(ppstmt, 0);
            strcpy(box_id_tmp, box_id);
            printf("box_id : %s\n", box_id_tmp);
			sqlite3_finalize(ppstmt);
			sqlite3_close(db);
			break;
		}
		else
		{
			printf("select box_id failure!\n");
			sqlite3_finalize(ppstmt);
			sqlite3_close(db);
			sleep(1);
			db_cnt++;
		}
	}

	printf("----------------send http request-------------\n");
	sprintf(url, "http://www.ailvgobox.com/box_manage_2/box_conf_change_1.php?box_id=%s", box_id_tmp);
	printf("request_url : %s\n",url);

	req = ghttp_request_new();
	strcpy(http_body, send_http_request(req, url));
    ghttp_request_destroy(req);
	
	printf("http_body : %s\n", http_body);
    printf("length of http_body : %d\n", strlen(http_body));
        
	cJSON *node;

    if(strlen(http_body) <= 2)
		printf("HTTP failure!\n");
    else
    {
        printf("HTTP success!\n");

        if(strcmp(http_body, "null") == 0)
            printf("http_body : null, no box_conf_change!\n");
        else
        {
	        node = cJSON_Parse(http_body);
            ParseJSON(node);
        }
    }
	
	printf("box_conf_chanage : complete!\n");

	if(change_flag == 1)
	{
		printf("reboot due to conf change!\n");
		sleep(5);
		system("reboot");
	}
}
コード例 #6
0
void
vca_illegal_parking::process_event()
{
    try
    {
        while ( true )
        {
            // Check if there are yet-to-be-fillout_event events in the database.
            auto sql = global::get_database_handle();
            sqlite3_stmt* stmt;
            ostringstream query;

            query << "SELECT * FROM events WHERE snapshots_fetched=0"
                  << " and producer='" << name_ << "'";
            auto query_cstr = query.str().c_str();
            sqlite3_prepare_v2(sql, query_cstr, strlen ( query_cstr ) + 1, &stmt, NULL );

            string evt_ts;
            string evt_id;
            int retval = sqlite3_step(stmt);
            if (retval == SQLITE_ROW)
            {
                evt_id = string ( reinterpret_cast< const char *> ( sqlite3_column_text ( stmt, 0 ) ) );
                evt_ts = string ( reinterpret_cast< const char *> ( sqlite3_column_text ( stmt, 1 ) ) );
                sqlite3_finalize(stmt);
            }
            else
            {
                boost::this_thread::sleep ( seconds ( 5 ) );
                continue;
            }

            auto evt_time = common::parse_utc_string ( evt_ts );

            boost::this_thread::sleep ( seconds ( 10 ) );
            LOG ( INFO ) << "filling out event id: " << evt_id
                        << " at: " << evt_ts;

            // Create directory for event.
            path evt_dir = operator/ ( working_dir_, common::get_simple_utc_string ( evt_time ) );
            create_directories ( evt_dir );

            auto pre_event_period = parameters_.get ( "pre_event_period", 300 );
            auto post_event_period = parameters_.get ( "post_event_period", 300 );
            auto start_time = evt_time - seconds ( pre_event_period );
            auto end_time = evt_time + seconds ( post_event_period );

            ptime now ( microsec_clock::universal_time() );
            auto dt = now - end_time;
            if ( dt <= seconds ( 0 ) )
            {
                boost::this_thread::sleep ( seconds ( -dt.seconds() ) );
            }

            // Copy snapshots to event directory.
            auto images = loiter_->list_snapshots_between ( start_time, end_time );

            BOOST_FOREACH ( auto const& image, images )
            {
                path to = operator/ ( evt_dir, image.filename() );
                copy_file ( image, to, copy_option::overwrite_if_exists );

            }
        }
    }
    catch ( std::exception const& e )
    {
        LOG ( INFO ) << e.what();
    }
}
コード例 #7
0
static void pk_backend_install_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
	gchar *dest_dir_name, **pkg_tokens, **pkg_ids;
	guint i;
	gdouble percent_step;
	GSList *repo, *install_list = NULL, *l;
	sqlite3_stmt *pkglist_stmt = NULL, *collection_stmt = NULL;
    PkBitfield transaction_flags = 0;
	PkInfoEnum ret;
	PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);

	g_variant_get(params, "(t^a&s)", &transaction_flags, &pkg_ids);
	pk_backend_job_set_status(job, PK_STATUS_ENUM_DEP_RESOLVE);

	if ((sqlite3_prepare_v2(job_data->db,
							"SELECT summary, cat FROM pkglist NATURAL JOIN repos "
							"WHERE name LIKE @name AND ver LIKE @ver AND arch LIKE @arch AND repo LIKE @repo",
							-1,
							&pkglist_stmt,
							NULL) != SQLITE_OK) ||
		(sqlite3_prepare_v2(job_data->db,
						   "SELECT (c.collection_pkg || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, "
						   "p.full_name, p.ext FROM collections AS c "
						   "JOIN pkglist AS p ON c.collection_pkg = p.name "
						   "JOIN repos AS r ON p.repo_order = r.repo_order "
						   "WHERE c.name LIKE @name AND r.repo LIKE @repo",
						   -1,
						   &collection_stmt,
						   NULL) != SQLITE_OK)) {
		pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
		goto out;
	}

	for (i = 0; pkg_ids[i]; i++) {
		pkg_tokens = pk_package_id_split(pkg_ids[i]);
		sqlite3_bind_text(pkglist_stmt, 1, pkg_tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
		sqlite3_bind_text(pkglist_stmt, 2, pkg_tokens[PK_PACKAGE_ID_VERSION], -1, SQLITE_TRANSIENT);
		sqlite3_bind_text(pkglist_stmt, 3, pkg_tokens[PK_PACKAGE_ID_ARCH], -1, SQLITE_TRANSIENT);
		sqlite3_bind_text(pkglist_stmt, 4, pkg_tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);

		if (sqlite3_step(pkglist_stmt) == SQLITE_ROW) {

			/* If it isn't a collection */
			if (g_strcmp0((gchar *) sqlite3_column_text(pkglist_stmt, 1), "collections")) {
				if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
					pk_backend_job_package(job, PK_INFO_ENUM_INSTALLING,
										   pkg_ids[i],
										   (gchar *) sqlite3_column_text(pkglist_stmt, 0));
				} else {
					install_list = g_slist_append(install_list, g_strdup(pkg_ids[i]));
				}
			} else {
				sqlite3_bind_text(collection_stmt, 1, pkg_tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
				sqlite3_bind_text(collection_stmt, 2, pkg_tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);

				while (sqlite3_step(collection_stmt) == SQLITE_ROW) {
					ret = katja_pkg_is_installed((gchar *) sqlite3_column_text(collection_stmt, 2));
					if ((ret == PK_INFO_ENUM_INSTALLING) || (ret == PK_INFO_ENUM_UPDATING)) {
						if ((pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) &&
							!g_strcmp0((gchar *) sqlite3_column_text(collection_stmt, 3), "obsolete")) {
							/* TODO: Don't just skip obsolete packages but remove them */
						} else if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
							pk_backend_job_package(job, ret,
												   (gchar *) sqlite3_column_text(collection_stmt, 0),
												   (gchar *) sqlite3_column_text(collection_stmt, 1));
						} else {
							install_list = g_slist_append(install_list,
														  g_strdup((gchar *) sqlite3_column_text(collection_stmt, 0)));
						}
					}
				}

				sqlite3_clear_bindings(collection_stmt);
				sqlite3_reset(collection_stmt);
			}
		}

		sqlite3_clear_bindings(pkglist_stmt);
		sqlite3_reset(pkglist_stmt);
		g_strfreev(pkg_tokens);
	}

	if (install_list && !pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
		/* / 2 means total percentage for installing and for downloading */
		percent_step = 100.0 / g_slist_length(install_list) / 2;

		/* Download the packages */
		pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD);
		dest_dir_name = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "downloads", NULL);
		for (l = install_list, i = 0; l; l = g_slist_next(l), i++) {
			pk_backend_job_set_percentage(job, percent_step * i);
			pkg_tokens = pk_package_id_split(l->data);
			repo = g_slist_find_custom(repos, pkg_tokens[PK_PACKAGE_ID_DATA], katja_cmp_repo);

			if (repo)
				katja_pkgtools_download(KATJA_PKGTOOLS(repo->data), job,
										dest_dir_name,
										pkg_tokens[PK_PACKAGE_ID_NAME]);
			g_strfreev(pkg_tokens);
		}
		g_free(dest_dir_name);

		/* Install the packages */
		pk_backend_job_set_status(job, PK_STATUS_ENUM_INSTALL);
		for (l = install_list; l; l = g_slist_next(l), i++) {
			pk_backend_job_set_percentage(job, percent_step * i);
			pkg_tokens = pk_package_id_split(l->data);
			repo = g_slist_find_custom(repos, pkg_tokens[PK_PACKAGE_ID_DATA], katja_cmp_repo);

			if (repo)
				katja_pkgtools_install(KATJA_PKGTOOLS(repo->data), job, pkg_tokens[PK_PACKAGE_ID_NAME]);
			g_strfreev(pkg_tokens);
		}
	}
	g_slist_free_full(install_list, g_free);

out:
	sqlite3_finalize(pkglist_stmt);
	sqlite3_finalize(collection_stmt);

	pk_backend_job_finished (job);
}
コード例 #8
0
ファイル: qgsstylev2.cpp プロジェクト: Nald/Quantum-GIS
bool QgsStyleV2::load( QString filename )
{
  mErrorString.clear();

  // Open the sqlite database
  if ( !openDB( filename ) )
  {
    mErrorString = "Unable to open database file specified";
    QgsDebugMsg( mErrorString );
    return false;
  }

  // Make sure there are no Null fields in parenting symbols ang groups
  char *query = sqlite3_mprintf( "UPDATE symbol SET groupid=0 WHERE groupid IS NULL;"
                                 "UPDATE colorramp SET groupid=0 WHERE groupid IS NULL;"
                                 "UPDATE symgroup SET parent=0 WHERE parent IS NULL;");
  runEmptyQuery( query );

  // First create all the main symbols
  query = sqlite3_mprintf( "SELECT * FROM symbol" );

  sqlite3_stmt *ppStmt;
  int nError = sqlite3_prepare_v2( mCurrentDB, query, -1, &ppStmt, NULL );
  while ( nError == SQLITE_OK && sqlite3_step( ppStmt ) == SQLITE_ROW )
  {
    QDomDocument doc;
    QString symbol_name = QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, SymbolName ) );
    QString xmlstring = QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, SymbolXML ) );
    if ( !doc.setContent( xmlstring ) )
    {
      QgsDebugMsg( "Cannot open symbol " + symbol_name );
      continue;
    }

    QDomElement symElement = doc.documentElement();
    QgsSymbolV2 *symbol = QgsSymbolLayerV2Utils::loadSymbol( symElement );
    if ( symbol != NULL )
      mSymbols.insert( symbol_name, symbol );
  }

  sqlite3_finalize( ppStmt );

  query = sqlite3_mprintf( "SELECT * FROM colorramp" );
  nError = sqlite3_prepare_v2( mCurrentDB, query, -1, &ppStmt, NULL );
  while ( nError == SQLITE_OK && sqlite3_step( ppStmt ) == SQLITE_ROW )
  {
    QDomDocument doc;
    QString ramp_name = QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, ColorrampName ) );
    QString xmlstring = QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, ColorrampXML ) );
    if ( !doc.setContent( xmlstring ) )
    {
      QgsDebugMsg( "Cannot open symbol " + ramp_name );
      continue;
    }
    QDomElement rampElement = doc.documentElement();
    QgsVectorColorRampV2 *ramp = QgsSymbolLayerV2Utils::loadColorRamp( rampElement );
    if ( ramp )
      mColorRamps.insert( ramp_name, ramp );
  }

  mFileName = filename;
  return true;
}
コード例 #9
0
ファイル: qgsstylev2.cpp プロジェクト: Nald/Quantum-GIS
QStringList QgsStyleV2::findSymbols( QString qword )
{
  if ( !mCurrentDB )
  {
    QgsDebugMsg( "Sorry! Cannot open database to search" );
    return QStringList();
  }

  char *query = sqlite3_mprintf( "SELECT name FROM symbol WHERE xml LIKE '%%%q%%'", qword.toUtf8().constData() );

  sqlite3_stmt *ppStmt;
  int nErr = sqlite3_prepare_v2( mCurrentDB, query, -1, &ppStmt, NULL );

  QStringList symbols;
  while ( nErr == SQLITE_OK && sqlite3_step( ppStmt ) == SQLITE_ROW )
  {
    symbols << QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, 0 ) );
  }

  sqlite3_finalize( ppStmt );


  query = sqlite3_mprintf( "SELECT id FROM tag WHERE name LIKE '%%%q%%'", qword.toUtf8().constData() );
  nErr = sqlite3_prepare_v2( mCurrentDB, query, -1, &ppStmt, NULL );

  QStringList tagids;
  while ( nErr == SQLITE_OK && sqlite3_step( ppStmt ) == SQLITE_ROW )
  {
    tagids << QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, 0 ) );
  }

  sqlite3_finalize( ppStmt );


  QString dummy = tagids.join( ", " );

  query = sqlite3_mprintf( "SELECT symbol_id FROM tagmap WHERE tag_id IN (%q)", dummy.toUtf8().constData() );
  nErr = sqlite3_prepare_v2( mCurrentDB, query, -1, &ppStmt, NULL );

  QStringList symbolids;
  while ( nErr == SQLITE_OK && sqlite3_step( ppStmt ) == SQLITE_ROW )
  {
    symbolids << QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, 0 ) );
  }

  sqlite3_finalize( ppStmt );


  dummy = symbolids.join( ", " );
  query = sqlite3_mprintf( "SELECT name FROM symbol WHERE id IN (%q)", dummy.toUtf8().constData() );
  nErr = sqlite3_prepare_v2( mCurrentDB, query, -1, &ppStmt, NULL );
  while ( nErr == SQLITE_OK && sqlite3_step( ppStmt ) == SQLITE_ROW )
  {
    QString symbolName = QString::fromUtf8(( const char * ) sqlite3_column_text( ppStmt, 0 ) );
    if ( !symbols.contains( symbolName ) )
      symbols << symbolName;
  }

  sqlite3_finalize( ppStmt );

  return symbols;
}
コード例 #10
0
ファイル: table_sqlite.c プロジェクト: ryanakca/OpenSMTPD
static int
table_sqlite_lookup(int service, const char *key, char *dst, size_t sz)
{
    sqlite3_stmt	*stmt;
    const char	*value;
    int		 r, s;

    stmt = table_sqlite_query(key, service);
    if (stmt == NULL)
        return (-1);

    s = sqlite3_step(stmt);
    if (s == SQLITE_DONE) {
        sqlite3_reset(stmt);
        return (0);
    }

    if (s != SQLITE_ROW) {
        log_warnx("warn: table-sqlite: sqlite3_step: %s",
                  sqlite3_errmsg(db));
        sqlite3_reset(stmt);
        return (-1);
    }

    r = 1;

    switch(service) {
    case K_ALIAS:
        do {
            value = sqlite3_column_text(stmt, 0);
            if (dst[0] && strlcat(dst, ", ", sz) >= sz) {
                log_warnx("warn: table-sqlite: result too large");
                r = -1;
                break;
            }
            if (strlcat(dst, value, sz) >= sz) {
                log_warnx("warn: table-sqlite: result too large");
                r = -1;
                break;
            }
            s = sqlite3_step(stmt);
        } while (s == SQLITE_ROW);

        if (s !=  SQLITE_ROW && s != SQLITE_DONE) {
            log_warnx("warn: table-sqlite: sqlite3_step: %s",
                      sqlite3_errmsg(db));
            r = -1;
        }
        break;
    case K_CREDENTIALS:
        if (snprintf(dst, sz, "%s:%s",
                     sqlite3_column_text(stmt, 0),
                     sqlite3_column_text(stmt, 1)) > (ssize_t)sz) {
            log_warnx("warn: table-sqlite: result too large");
            r = -1;
        }
        break;
    case K_USERINFO:
        if (snprintf(dst, sz, "%s:%i:%i:%s",
                     sqlite3_column_text(stmt, 0),
                     sqlite3_column_int(stmt, 1),
                     sqlite3_column_int(stmt, 2),
                     sqlite3_column_text(stmt, 3)) > (ssize_t)sz) {
            log_warnx("warn: table-sqlite: result too large");
            r = -1;
        }
        break;
    case K_DOMAIN:
    case K_NETADDR:
    case K_SOURCE:
    case K_MAILADDR:
    case K_ADDRNAME:
        if (strlcpy(dst, sqlite3_column_text(stmt, 0), sz) >= sz) {
            log_warnx("warn: table-sqlite: result too large");
            r = -1;
        }
        break;
    default:
        log_warnx("warn: table-sqlite: unknown service %i", service);
        r = -1;
    }

    return (r);
}
コード例 #11
0
ファイル: fts3view.c プロジェクト: mingodad/sqlite
/*
** Report on the vocabulary.  This creates an fts4aux table with a random
** name, but deletes it in the end.
*/
static void showVocabulary(sqlite3 *db, const char *zTab) {
    char *zAux;
    sqlite3_uint64 r;
    sqlite3_stmt *pStmt;
    int nDoc = 0;
    int nToken = 0;
    int nOccurrence = 0;
    int nTop;
    int n, i;

    sqlite3_randomness(sizeof(r), &r);
    zAux = sqlite3_mprintf("viewer_%llx", zTab, r);
    runSql(db, "BEGIN");
    pStmt = prepare(db, "SELECT count(*) FROM %Q", zTab);
    while( sqlite3_step(pStmt)==SQLITE_ROW ) {
        nDoc = sqlite3_column_int(pStmt, 0);
    }
    sqlite3_finalize(pStmt);
    printf("Number of documents...................... %9d\n", nDoc);

    runSql(db, "CREATE VIRTUAL TABLE %s USING fts4aux(%Q)", zAux, zTab);
    pStmt = prepare(db,
                    "SELECT count(*), sum(occurrences) FROM %s WHERE col='*'",
                    zAux);
    while( sqlite3_step(pStmt)==SQLITE_ROW ) {
        nToken = sqlite3_column_int(pStmt, 0);
        nOccurrence = sqlite3_column_int(pStmt, 1);
    }
    sqlite3_finalize(pStmt);
    printf("Total tokens in all documents............ %9d\n", nOccurrence);
    printf("Total number of distinct tokens.......... %9d\n", nToken);
    if( nToken==0 ) goto end_vocab;

    n = 0;
    pStmt = prepare(db, "SELECT count(*) FROM %s"
                    " WHERE col='*' AND occurrences==1", zAux);
    while( sqlite3_step(pStmt)==SQLITE_ROW ) {
        n = sqlite3_column_int(pStmt, 0);
    }
    sqlite3_finalize(pStmt);
    printf("Tokens used exactly once................. %9d %5.2f%%\n",
           n, n*100.0/nToken);

    n = 0;
    pStmt = prepare(db, "SELECT count(*) FROM %s"
                    " WHERE col='*' AND documents==1", zAux);
    while( sqlite3_step(pStmt)==SQLITE_ROW ) {
        n = sqlite3_column_int(pStmt, 0);
    }
    sqlite3_finalize(pStmt);
    printf("Tokens used in only one document......... %9d %5.2f%%\n",
           n, n*100.0/nToken);

    if( nDoc>=2000 ) {
        n = 0;
        pStmt = prepare(db, "SELECT count(*) FROM %s"
                        " WHERE col='*' AND occurrences<=%d", zAux, nDoc/1000);
        while( sqlite3_step(pStmt)==SQLITE_ROW ) {
            n = sqlite3_column_int(pStmt, 0);
        }
        sqlite3_finalize(pStmt);
        printf("Tokens used in 0.1%% or less of docs...... %9d %5.2f%%\n",
               n, n*100.0/nToken);
    }

    if( nDoc>=200 ) {
        n = 0;
        pStmt = prepare(db, "SELECT count(*) FROM %s"
                        " WHERE col='*' AND occurrences<=%d", zAux, nDoc/100);
        while( sqlite3_step(pStmt)==SQLITE_ROW ) {
            n = sqlite3_column_int(pStmt, 0);
        }
        sqlite3_finalize(pStmt);
        printf("Tokens used in 1%% or less of docs........ %9d %5.2f%%\n",
               n, n*100.0/nToken);
    }

    nTop = atoi(findOption("top", 1, "25"));
    printf("The %d most common tokens:\n", nTop);
    pStmt = prepare(db,
                    "SELECT term, documents FROM %s"
                    " WHERE col='*'"
                    " ORDER BY documents DESC, term"
                    " LIMIT %d", zAux, nTop);
    i = 0;
    while( sqlite3_step(pStmt)==SQLITE_ROW ) {
        i++;
        n = sqlite3_column_int(pStmt, 1);
        printf("  %2d. %-30s %9d docs %5.2f%%\n", i,
               sqlite3_column_text(pStmt, 0), n, n*100.0/nDoc);
    }
    sqlite3_finalize(pStmt);

end_vocab:
    runSql(db, "ROLLBACK");
    sqlite3_free(zAux);
}
コード例 #12
0
ファイル: dc_job.c プロジェクト: r10s/messenger-backend
static void dc_job_perform(dc_context_t* context, int thread, int probe_network)
{
	sqlite3_stmt* select_stmt = NULL;
	dc_job_t      job;
	#define       THREAD_STR (thread==DC_IMAP_THREAD? "INBOX" : "SMTP")
	#define       IS_EXCLUSIVE_JOB (DC_JOB_CONFIGURE_IMAP==job.action || DC_JOB_IMEX_IMAP==job.action)

	memset(&job, 0, sizeof(dc_job_t));
	job.param = dc_param_new();

	if (context==NULL || context->magic!=DC_CONTEXT_MAGIC) {
		goto cleanup;
	}

	if (probe_network==0) {
		// processing for first-try and after backoff-timeouts:
		// process jobs in the order they were added.
		#define FIELDS "id, action, foreign_id, param, added_timestamp, desired_timestamp, tries"
		select_stmt = dc_sqlite3_prepare(context->sql,
			"SELECT " FIELDS " FROM jobs"
			" WHERE thread=? AND desired_timestamp<=?"
			" ORDER BY action DESC, added_timestamp;");
		sqlite3_bind_int64(select_stmt, 1, thread);
		sqlite3_bind_int64(select_stmt, 2, time(NULL));
	}
	else {
		// processing after call to dc_maybe_network():
		// process _all_ pending jobs that failed before
		// in the order of their backoff-times.
		select_stmt = dc_sqlite3_prepare(context->sql,
			"SELECT " FIELDS " FROM jobs"
			" WHERE thread=? AND tries>0"
			" ORDER BY desired_timestamp, action DESC;");
		sqlite3_bind_int64(select_stmt, 1, thread);
	}

	while (sqlite3_step(select_stmt)==SQLITE_ROW)
	{
		job.job_id                          = sqlite3_column_int  (select_stmt, 0);
		job.action                          = sqlite3_column_int  (select_stmt, 1);
		job.foreign_id                      = sqlite3_column_int  (select_stmt, 2);
		dc_param_set_packed(job.param, (char*)sqlite3_column_text (select_stmt, 3));
		job.added_timestamp                 = sqlite3_column_int64(select_stmt, 4);
		job.desired_timestamp               = sqlite3_column_int64(select_stmt, 5);
		job.tries                           = sqlite3_column_int  (select_stmt, 6);

		dc_log_info(context, 0, "%s-job #%i, action %i started...", THREAD_STR, (int)job.job_id, (int)job.action);

		// some configuration jobs are "exclusive":
		// - they are always executed in the imap-thread and the smtp-thread is suspended during execution
		// - they may change the database handle change the database handle; we do not keep old pointers therefore
		// - they can be re-executed one time AT_ONCE, but they are not save in the database for later execution
		if (IS_EXCLUSIVE_JOB) {
			dc_job_kill_action(context, job.action);
			sqlite3_finalize(select_stmt);
			select_stmt = NULL;
			dc_jobthread_suspend(&context->sentbox_thread, 1);
			dc_jobthread_suspend(&context->mvbox_thread, 1);
			dc_suspend_smtp_thread(context, 1);
		}

		for (int tries = 0; tries <= 1; tries++)
		{
			job.try_again = DC_DONT_TRY_AGAIN; // this can be modified by a job using dc_job_try_again_later()

			switch (job.action) {
				case DC_JOB_SEND_MSG_TO_SMTP:     dc_job_do_DC_JOB_SEND                 (context, &job); break;
				case DC_JOB_DELETE_MSG_ON_IMAP:   dc_job_do_DC_JOB_DELETE_MSG_ON_IMAP   (context, &job); break;
				case DC_JOB_MARKSEEN_MSG_ON_IMAP: dc_job_do_DC_JOB_MARKSEEN_MSG_ON_IMAP (context, &job); break;
				case DC_JOB_MARKSEEN_MDN_ON_IMAP: dc_job_do_DC_JOB_MARKSEEN_MDN_ON_IMAP (context, &job); break;
				case DC_JOB_MOVE_MSG:             dc_job_do_DC_JOB_MOVE_MSG             (context, &job); break;
				case DC_JOB_SEND_MDN:             dc_job_do_DC_JOB_SEND                 (context, &job); break;
				case DC_JOB_CONFIGURE_IMAP:       dc_job_do_DC_JOB_CONFIGURE_IMAP       (context, &job); break;
				case DC_JOB_IMEX_IMAP:            dc_job_do_DC_JOB_IMEX_IMAP            (context, &job); break;
				case DC_JOB_MAYBE_SEND_LOCATIONS: dc_job_do_DC_JOB_MAYBE_SEND_LOCATIONS (context, &job); break;
				case DC_JOB_MAYBE_SEND_LOC_ENDED: dc_job_do_DC_JOB_MAYBE_SEND_LOC_ENDED (context, &job); break;
				case DC_JOB_HOUSEKEEPING:         dc_housekeeping                       (context);       break;
			}

			if (job.try_again!=DC_AT_ONCE) {
				break;
			}
		}

		if (IS_EXCLUSIVE_JOB) {
			dc_jobthread_suspend(&context->sentbox_thread, 0);
			dc_jobthread_suspend(&context->mvbox_thread, 0);
			dc_suspend_smtp_thread(context, 0);
			goto cleanup;
		}
		else if (job.try_again==DC_INCREATION_POLL)
		{
			// just try over next loop unconditionally, the ui typically interrupts idle when the file (video) is ready
			dc_log_info(context, 0, "%s-job #%i not yet ready and will be delayed.", THREAD_STR, (int)job.job_id);
		}
		else if (job.try_again==DC_AT_ONCE || job.try_again==DC_STANDARD_DELAY)
		{
			int tries = job.tries + 1;

			if( tries < JOB_RETRIES ) {
				job.tries = tries;

				time_t time_offset = get_backoff_time_offset(tries);
				job.desired_timestamp = job.added_timestamp + time_offset;

				dc_job_update(context, &job);
				dc_log_info(context, 0, "%s-job #%i not succeeded on try #%i, retry in ADD_TIME+%i (in %i seconds).", THREAD_STR, (int)job.job_id,
					tries, time_offset, (job.added_timestamp+time_offset)-time(NULL));

				if (thread==DC_SMTP_THREAD && tries<(JOB_RETRIES-1)) {
					pthread_mutex_lock(&context->smtpidle_condmutex);
						context->perform_smtp_jobs_needed = DC_JOBS_NEEDED_AVOID_DOS;
					pthread_mutex_unlock(&context->smtpidle_condmutex);
				}
			}
			else {
				if (job.action==DC_JOB_SEND_MSG_TO_SMTP) { // in all other cases, the messages is already sent
					dc_set_msg_failed(context, job.foreign_id, job.pending_error);
				}
				dc_job_delete(context, &job);
			}

			if (probe_network) {
				// on dc_maybe_network() we stop trying here;
				// these jobs are already tried once.
				// otherwise, we just continue with the next job
				// to give other jobs a chance being tried at least once.
				goto cleanup;
			}
		}
		else
		{
			dc_job_delete(context, &job);
		}
	}

cleanup:
	dc_param_unref(job.param);
	free(job.pending_error);
	sqlite3_finalize(select_stmt);
}
コード例 #13
0
ファイル: CSqlite.cpp プロジェクト: KnowNo/test-code-backup
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Function:获取一行数据内容
// Input:	ioValue, 保存一行数据
//          ioNull,    保存空值的标志 0  为空, 1 非空
// Output:
// Return:	SQLITE_BUSY:   数据库被锁
//          SQLITE_ROW:    数据未取完, 需要继续读取数据
//          SQLITE_DONE:   数据已经读取完成
//          other:         读取数据库记录失败
int CSQLite::Fetch( vector<string> & ioValues, vector<int>& ioNull )
{
    //清空数组
    ioValues.clear();
    ioNull.clear();
    bool bRelease = true; //是否释放游标

    for( unsigned int m = 0; m < m_nLimitNum; m++ )
    {
        m_nState = sqlite3_step( m_pStmt );

        if ( SQLITE_DONE  == m_nState )
        {
            // no rows
            m_strErrInfo = sqlite3_errmsg( m_pDb );
            goto __Exit;
        }
        else if ( SQLITE_ROW == m_nState )
        {
            //循环获取字段的内容
            for ( unsigned int i = 0; i < m_nCurFieldNum; i++ )
            {
                const char* pTmp = NULL;   //防止空值, modified by yinyong 2007.12.27
                pTmp = (const char*)( sqlite3_column_text( m_pStmt, i ) );
                 //有空值
                if ( NULL == pTmp )
                {
                    ioValues.push_back( "" );
                    ioNull.push_back(0);
                 }
                else
                {
                    ioValues.push_back( pTmp );
                    ioNull.push_back(1);
                }
            }
            bRelease = false;
            goto __Exit;
        }
        else if ( SQLITE_BUSY == m_nState )
        {
           if ( m_nLimitNum == m+1 )
           {
               m_strErrInfo = sqlite3_errmsg( m_pDb );
               goto __Exit;
           }
           sqlite3_busy_handler( m_pDb,NULL,NULL);
           Sleep( SLEEPTIME );
           continue;
        }
        else
        {
            //other exceptions
            m_strErrInfo = sqlite3_errmsg( m_pDb );
            goto __Exit;
        }
    }
__Exit:
    if ( NULL != m_pStmt && bRelease )
    {
        sqlite3_finalize( m_pStmt );
        m_pStmt = NULL;
    }
    return m_nState;
}
コード例 #14
0
ファイル: sqlitedataset.cpp プロジェクト: sandalsoft/mrmc
bool SqliteDataset::query(const std::string &query) {
    if(!handle()) throw DbErrors("No Database Connection");
    std::string qry = query;
    int fs = qry.find("select");
    int fS = qry.find("SELECT");
    if (!( fs >= 0 || fS >=0))                                 
         throw DbErrors("MUST be select SQL!"); 

  close();

  sqlite3_stmt *stmt = NULL;
  if (db->setErr(sqlite3_prepare_v2(handle(),query.c_str(),-1,&stmt, NULL),query.c_str()) != SQLITE_OK)
    throw DbErrors(db->getErrorMsg());

  // column headers
  const unsigned int numColumns = sqlite3_column_count(stmt);
  result.record_header.resize(numColumns);
  for (unsigned int i = 0; i < numColumns; i++)
    result.record_header[i].name = sqlite3_column_name(stmt, i);

  // returned rows
  while (sqlite3_step(stmt) == SQLITE_ROW)
  { // have a row of data
    sql_record *res = new sql_record;
    res->resize(numColumns);
    for (unsigned int i = 0; i < numColumns; i++)
    {
      field_value &v = res->at(i);
      switch (sqlite3_column_type(stmt, i))
      {
      case SQLITE_INTEGER:
        v.set_asInt64(sqlite3_column_int64(stmt, i));
        break;
      case SQLITE_FLOAT:
        v.set_asDouble(sqlite3_column_double(stmt, i));
        break;
      case SQLITE_TEXT:
        v.set_asString((const char *)sqlite3_column_text(stmt, i));
        break;
      case SQLITE_BLOB:
        v.set_asString((const char *)sqlite3_column_text(stmt, i));
        break;
      case SQLITE_NULL:
      default:
        v.set_asString("");
        v.set_isNull();
        break;
      }
    }
    result.records.push_back(res);
  }
  if (db->setErr(sqlite3_finalize(stmt),query.c_str()) == SQLITE_OK)
  {
    active = true;
    ds_state = dsSelect;
    this->first();
    return true;
  }
  else
  {
    throw DbErrors(db->getErrorMsg());
  }  
}
コード例 #15
0
ファイル: dbtoshm.c プロジェクト: myth9499/ups
int load_tranmap_cfg(char *table)
{
	int i=0;
	_tranmap *tmap=NULL;
	size_t shmsize;
	int	shmid=0;


	SysLog(LOG_SYS_SHOW,"开始装载交易映射配置表[%s]\n",table);
	/** init commmsg **/
	shmsize=MAXTRANMAP*sizeof(_tranmap);
	if((shmid=getshmid(5,shmsize))==-1)
	{
		SysLog(LOG_SYS_ERR,"获取交易映射配置共享内存失败\n");
		return -1;
	}
	tmap = (_tranmap *)shmat(shmid,NULL,0);
	if(tmap == NULL)
	{
		SysLog(LOG_SYS_ERR,"鏈接交易映射配置共享内存失败\n");
		return -1;
	}
	sprintf(sql,"%s %s","select * from ",table);
	rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);  
	if (rc != SQLITE_OK)  
	{  
		fprintf(stderr, "%s : %s\n", sql, sqlite3_errmsg(db));    
		sqlite3_close(db);    
		return -1;    
	}  

	ncolumn = sqlite3_column_count(stmt);
	while (sqlite3_step(stmt) == SQLITE_ROW)  
	{     
		for(i = 0 ; i < ncolumn ; i++ )  
		{  
			vtype = sqlite3_column_type(stmt , i);  
			column_name = sqlite3_column_name(stmt , i);  
			switch( vtype )  
			{  
				case SQLITE_NULL:  
					fprintf(stdout, "%s: null\n", column_name);     
					break;  
				case SQLITE_INTEGER:  
					fprintf(stdout, "%s: %d\n", column_name,sqlite3_column_int(stmt,i));    
					break;  
				case SQLITE_FLOAT:  
					fprintf(stdout, "%s: %f\n", column_name,sqlite3_column_double(stmt,i));     
					break;  
				case SQLITE_BLOB: /* arguably fall through... */  
					fprintf(stdout, "%s: BLOB\n", column_name);     
					break;  
				case SQLITE_TEXT:   
					fprintf(stdout, "%s: %s\n", column_name,sqlite3_column_text(stmt,i));   
					break;  
				default:  
					fprintf(stdout, "%s: ERROR [%s]\n", column_name, sqlite3_errmsg(db));   
					break;  
			}
			if(i==1)
			{	
				strcpy(tmap->trancode,sqlite3_column_text(stmt,i));
			}
			if(i==2)
			{
				strcpy(tmap->tranname,sqlite3_column_text(stmt,i));
			}	
			if(i==3)
			{
				strcpy(tmap->tranflow,sqlite3_column_text(stmt,i));
			}	
			if(i==4)
			{
				tmap->timeout=sqlite3_column_int(stmt,i);
			}
		}
		tmap++;
	}
	shmdt(tmap);
	SysLog(LOG_SYS_SHOW,"装载交易映射配置表[%s]成功\n",table);
	return 0;
}
コード例 #16
0
ファイル: fuse.c プロジェクト: Laukien/NightmareCommander
static int nc_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) {
	(void) offset;
	(void) fi;


	filler(buf, ".", NULL, 0);
	filler(buf, "..", NULL, 0);

	char *term = (char *)malloc(strlen(path) + 1 + 1);
	sprintf(term, "%s%%", path);

	sqlite3 *db;
	int rc;
	rc = sqlite3_open(dbf, &db);
	if (rc != SQLITE_OK) {
		showError("unable to open database");
		free(term);
		return 1;
	}
	sqlite3_stmt *stmt;

	/* directory */
	rc = sqlite3_prepare_v2(db, "SELECT name FROM directory WHERE name LIKE ? ORDER BY name ASC;", -1, &stmt, NULL);
	if (rc != SQLITE_OK) {
		showError(sqlite3_errmsg(db));
		sqlite3_finalize(stmt);
		sqlite3_close(db);
		free(term);
		return 1;
	}
	rc = sqlite3_bind_text(stmt, 1, term, strlen(term), SQLITE_STATIC);
	if (rc != SQLITE_OK) {
		showError(sqlite3_errmsg(db));
		sqlite3_finalize(stmt);
		sqlite3_close(db);
		free(term);
		return 1;
	}

	char *curr;
	char *next;
	char *name;
	char *last = NULL;
	while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
		curr = strdup((char *)sqlite3_column_text(stmt, 0));
		if (strcmp(curr, path) != 0) {
			next = strchr(curr + strlen(path) + 1, '/');
			if (next) {
				next[0] = '\0';
			}
			if (strstr(curr, path)) {
				if (strlen(path) == 1) {
					name = curr + 1;
				} else {
					name = curr + strlen(path) + 1;
				}
				if (!last || strcmp(name, last) != 0) {
					filler(buf, name, NULL, 0);
					if (last) {
						free(last);
					}
					last = strdup(name);
				}
			}
		}

		free(curr);
	}

	if (last) {
		free(last);
	}
	sqlite3_finalize(stmt);
	free(term);

	/* file */
	rc = sqlite3_prepare_v2(db, "SELECT f.name FROM directory AS d, file as f WHERE d.id=f.directory AND d.name=? ORDER by f.name ASC;", -1, &stmt, NULL);
	if (rc != SQLITE_OK) {
		showError(sqlite3_errmsg(db));
		sqlite3_finalize(stmt);
		sqlite3_close(db);
		return 1;
	}
	rc = sqlite3_bind_text(stmt, 1, path, strlen(path), SQLITE_STATIC);
	if (rc != SQLITE_OK) {
		showError(sqlite3_errmsg(db));
		sqlite3_finalize(stmt);
		sqlite3_close(db);
		return 1;
	}

	while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
		filler(buf, (char *)sqlite3_column_text(stmt, 0), NULL, 0);
	}

	sqlite3_finalize(stmt);
	sqlite3_close(db);

	return 0;
}
コード例 #17
0
ファイル: dbtoshm.c プロジェクト: myth9499/ups
int load_vardef_cfg(char *table)
{
	int i=0,shmid = 0;
	_vardef *vardef=NULL;
	size_t shmsize;


	SysLog(LOG_SYS_SHOW,"开始装载变量定义配置表[%s]\n",table);
	/** init vardef **/
	shmsize=MAXVARDEF*sizeof(_vardef);
	if((shmid=getshmid(4,shmsize))==-1)
	{
		SysLog(LOG_SYS_ERR,"获取交易定义配置共享内存失败\n");
		return -1;
	}
	vardef = (_vardef *)shmat(shmid,NULL,0);
	if(vardef == NULL)
	{
		SysLog(LOG_SYS_ERR,"链接交易定义配置共享内存失败\n");
		return -1;
	}
	sprintf(sql,"%s %s","select * from ",table);
	rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);  
	if (rc != SQLITE_OK)  
	{  
		fprintf(stderr, "%s : %s\n", sql, sqlite3_errmsg(db));    
		sqlite3_close(db);    
		return -1;    
	}  

	ncolumn = sqlite3_column_count(stmt);
	while (sqlite3_step(stmt) == SQLITE_ROW)  
	{     
		for(i = 0 ; i < ncolumn ; i++ )  
		{  
			vtype = sqlite3_column_type(stmt , i);  
			column_name = sqlite3_column_name(stmt , i);  
			switch( vtype )  
			{  
				case SQLITE_NULL:  
					fprintf(stdout, "%s: null\n", column_name);     
					break;  
				case SQLITE_INTEGER:  
					fprintf(stdout, "%s: %d\n", column_name,sqlite3_column_int(stmt,i));    
					break;  
				case SQLITE_FLOAT:  
					fprintf(stdout, "%s: %f\n", column_name,sqlite3_column_double(stmt,i));     
					break;  
				case SQLITE_BLOB: /* arguably fall through... */  
					fprintf(stdout, "%s: BLOB\n", column_name);     
					break;  
				case SQLITE_TEXT:   
					fprintf(stdout, "%s: %s\n", column_name,sqlite3_column_text(stmt,i));   
					break;  
				default:  
					fprintf(stdout, "%s: ERROR [%s]\n", column_name, sqlite3_errmsg(db));   
					break;  
			}
			if(i==1)
			{	
				strcpy(vardef->varname,sqlite3_column_text(stmt,i));
			}
			if(i==2)
			{
				strcpy(vardef->varmark,sqlite3_column_text(stmt,i));
			}	
			if(i==3)
			{
				strcpy(vardef->vartype,sqlite3_column_text(stmt,i));
			}	
			if(i==4)
			{
				vardef->varlen=sqlite3_column_int(stmt,i);
			}
		}
		vardef++;
	}
	shmdt(vardef);
	SysLog(LOG_SYS_SHOW,"装载变量定义配置表[%s]成功\n",table);
	return 0;
}
コード例 #18
0
int cals_get_alarm_info(const int event_id, GList **alarm_list)
{
	int ret = -1;
	GList *result = NULL;
	sqlite3_stmt *stmt = NULL;
	cal_value * cvalue = NULL;
	char query[CALS_SQL_MAX_LEN] = {0};
	cal_alarm_info_t* alarm_info = NULL;

	retv_if(NULL == alarm_list, CAL_ERR_ARG_NULL);

	sprintf(query, "SELECT * FROM %s WHERE event_id=%d", CALS_TABLE_ALARM, event_id);

	stmt = cals_query_prepare(query);
	retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");

	ret = cals_stmt_step(stmt);
	if (ret < CAL_SUCCESS) {
		sqlite3_finalize(stmt);
		ERR("cals_stmt_step() Failed(%d)", ret);
		return ret;
	}

	while (CAL_TRUE == ret)
	{
		cvalue = calloc(1, sizeof(cal_value));
		if (NULL == cvalue) {
			sqlite3_finalize(stmt);
			g_list_foreach(result, _cals_alarm_value_free, NULL);
			g_list_free(result);
			ERR("calloc() Failed(%d)", errno);
			return CAL_ERR_OUT_OF_MEMORY;
		}

		cvalue->v_type = CAL_EVENT_ALARM;
		cvalue->user_data = alarm_info = calloc(1, sizeof(cal_alarm_info_t));
		if (NULL == alarm_info) {
			sqlite3_finalize(stmt);
			g_list_foreach(result, _cals_alarm_value_free, NULL);
			g_list_free(result);
			free(cvalue);
			ERR("calloc() Failed(%d)", errno);
			return CAL_ERR_OUT_OF_MEMORY;
		}

		alarm_info->event_id = sqlite3_column_int(stmt, 0);

		alarm_info->alarm_time = sqlite3_column_int64(stmt, 1);
		alarm_info->remind_tick = sqlite3_column_int(stmt, 2);
		alarm_info->remind_tick_unit = sqlite3_column_int(stmt, 3);
		alarm_info->alarm_tone = SAFE_STRDUP(sqlite3_column_text(stmt, 4));
		alarm_info->alarm_description = SAFE_STRDUP(sqlite3_column_text(stmt, 5));
		alarm_info->alarm_type = sqlite3_column_int(stmt, 6);
		alarm_info->alarm_id = sqlite3_column_int(stmt, 7);

		result = g_list_append(result, cvalue);

		ret = cals_stmt_step(stmt);
	}
	sqlite3_finalize(stmt);

	*alarm_list = result;

	return CAL_SUCCESS;
}
コード例 #19
0
static void pk_backend_get_details_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
	gchar **pkg_ids, **pkg_tokens, *homepage = NULL;
	gsize i;
	GString *desc;
	GRegex *expr;
	GMatchInfo *match_info;
	GError *err = NULL;
	sqlite3_stmt *stmt;
	PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);

	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);

	g_variant_get(params, "(^a&s)", &pkg_ids);

	if ((sqlite3_prepare_v2(job_data->db,
							"SELECT p.desc, p.cat, p.uncompressed FROM pkglist AS p NATURAL JOIN repos AS r "
							"WHERE name LIKE @name AND r.repo LIKE @repo AND ext NOT LIKE 'obsolete'",
							-1,
							&stmt,
							NULL) != SQLITE_OK)) {
		pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
		goto out;
	}

	pkg_tokens = pk_package_id_split(pkg_ids[0]);
	sqlite3_bind_text(stmt, 1, pkg_tokens[PK_PACKAGE_ID_NAME], -1, SQLITE_TRANSIENT);
	sqlite3_bind_text(stmt, 2, pkg_tokens[PK_PACKAGE_ID_DATA], -1, SQLITE_TRANSIENT);
	g_strfreev(pkg_tokens);

	if (sqlite3_step(stmt) != SQLITE_ROW)
		goto out;

	desc = g_string_new((gchar *) sqlite3_column_text(stmt, 0));

	/* Regular expression for searching a homepage */
	expr = g_regex_new("(?:http|ftp):\\/\\/[[:word:]\\/\\-\\.]+[[:word:]\\/](?=\\.?$)",
			G_REGEX_OPTIMIZE | G_REGEX_DUPNAMES,
			0,
			&err);
	if (err) {
		pk_backend_job_error_code(job, PK_ERROR_ENUM_UNKNOWN, "%s", err->message);
		g_error_free(err);
		goto out;
	}
	if (g_regex_match(expr, desc->str, 0, &match_info)) {
		homepage = g_match_info_fetch(match_info, 0); /* URL */
		/* Remove the last sentence with the copied URL */
		for (i = desc->len - 1; i > 0; i--) {
			if ((desc->str[i - 1] == '.') && (desc->str[i] == ' ')) {
				g_string_truncate(desc, i);
				break;
			}
		}
		g_match_info_free(match_info);
	}
	g_regex_unref(expr);

	/* Ready */
	pk_backend_job_details(job, pkg_ids[0],
						   NULL,
						   NULL,
						   pk_group_enum_from_string((gchar *) sqlite3_column_text(stmt, 1)),
						   desc->str,
						   homepage,
						   sqlite3_column_int(stmt, 2));

	g_free(homepage);
	if (desc)
		g_string_free(desc, TRUE);

out:
	sqlite3_finalize(stmt);

	pk_backend_job_finished(job);
}
コード例 #20
0
ファイル: sqlite.c プロジェクト: xujun10110/I-GNOKII
GNOKII_API void DB_Look(const gchar * const phone)
{
    GString *buf, *phnStr, *timebuf;
    gint ret1, numError, error;
    time_t rawtime;
    struct tm * timeinfo;
    sqlite3_stmt * stmt;

    if (phone[0] == '\0')
        phnStr = g_string_new("");
    else {
        phnStr = g_string_sized_new(32);
        g_string_printf(phnStr, "AND phone = '%s'", phone);
    }

    time(&rawtime);
    timeinfo = localtime(&rawtime);

    timebuf = g_string_sized_new(25);
    g_string_printf(timebuf, "'%02d:%02d:%02d'",
                    timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);

    sqlite3_exec(ppDbOutbox, "BEGIN TRANSACTION;", NULL, NULL, NULL);

    /* poll for outgoing messages */
    buf = g_string_sized_new(256);
    g_string_printf(buf, "SELECT id, number, text, dreport FROM outbox \
                        WHERE processed=0 \
                        AND %s >= not_before \
                        AND %s <= not_after \
                        %s", timebuf->str, timebuf->str, phnStr->str);

    g_string_free(phnStr, TRUE);

    ret1 = sqlite3_prepare_v2(ppDbOutbox, buf->str, -1, &stmt, NULL);
    if (ret1 != SQLITE_OK) {
        g_print(_("%d: Parsing query %s failed!"), __LINE__, buf->str);
        g_print(_("Error: %s"), sqlite3_errmsg(ppDbInbox));
        return;
    }

    g_string_printf(timebuf, "'%02d-%02d-%02d %02d:%02d:%02d'",
                    timeinfo->tm_year, timeinfo->tm_mon,
                    timeinfo->tm_mday, timeinfo->tm_hour,
                    timeinfo->tm_min, timeinfo->tm_sec
                   );

    ret1 = sqlite3_step(stmt);
    while (ret1 == SQLITE_ROW) {
        int gerror = 0;
        gn_sms sms;

        gn_sms_default_submit(&sms);
        memset(&sms.remote.number, 0, sizeof (sms.remote.number));
        sms.delivery_report = sqlite3_column_int(stmt, 3);

        strncpy(sms.remote.number, sqlite3_column_text(stmt, 1), sizeof (sms.remote.number) - 1);
        sms.remote.number[sizeof (sms.remote.number) - 1] = '\0';
        if (sms.remote.number[0] == '+')
            sms.remote.type = GN_GSM_NUMBER_International;
        else
            sms.remote.type = GN_GSM_NUMBER_Unknown;

        strncpy((gchar *) sms.user_data[0].u.text, sqlite3_column_text(stmt, 2), 10 * GN_SMS_MAX_LENGTH + 1);
        sms.user_data[0].u.text[10 * GN_SMS_MAX_LENGTH] = '\0';
        sms.user_data[0].length = strlen((gchar *) sms.user_data[0].u.text);
        sms.user_data[0].type = GN_SMS_DATA_Text;
        sms.user_data[1].type = GN_SMS_DATA_None;
        if (!gn_char_def_alphabet(sms.user_data[0].u.text))
            sms.dcs.u.general.alphabet = GN_SMS_DCS_UCS2;

        gn_log_xdebug("Sending SMS: %s, %s\n", sms.remote.number, sms.user_data[0].u.text);

        numError = 0;
        do {
            error = WriteSMS(&sms);
            sleep(1);
        } while ((error == GN_ERR_TIMEOUT || error == GN_ERR_FAILED) && numError++ < 3);

        /* mark sended */
        g_string_printf(buf, "UPDATE outbox SET processed=1, error='%d', \
                        processed_date=%s \
                        WHERE id=%d",
                        gerror, timebuf->str, sqlite3_column_int(stmt, 0)
                       );

        sqlite3_exec(ppDbOutbox, buf->str, NULL, NULL, NULL);
        ret1 = sqlite3_step(stmt);
    }

    /* rollback if found any errors */
    if (ret1 != SQLITE_DONE) {
        g_print(_("%d: SELECT FROM outbox command failed.\n"), __LINE__);
        g_print(_("Error: %s\n"), sqlite3_errmsg(ppDbOutbox));
        sqlite3_finalize(stmt);
        sqlite3_exec(ppDbOutbox, "ROLLBACK TRANSACTION;", NULL, NULL, NULL);

        g_string_free(timebuf, TRUE);
        g_string_free(buf, TRUE);
        return;
    }
    sqlite3_finalize(stmt);
    sqlite3_exec(ppDbOutbox, "COMMIT;", NULL, NULL, NULL);

    g_string_free(timebuf, TRUE);
    g_string_free(buf, TRUE);
}
コード例 #21
0
static void pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
	gchar *pkg_id, *full_name, *desc, **pkg_tokens;
	const gchar *pkg_metadata_filename;
	GFile *pkg_metadata_dir;
	GFileEnumerator *pkg_metadata_enumerator;
	GFileInfo *pkg_metadata_file_info;
	GError *err = NULL;
	sqlite3_stmt *stmt;
	PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);

	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);

	if ((sqlite3_prepare_v2(job_data->db,
							"SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext "
							"FROM pkglist AS p1 NATURAL JOIN repos AS r "
							"WHERE p1.name LIKE @name AND p1.repo_order = "
							"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)",
							-1,
							&stmt,
							NULL) != SQLITE_OK)) {
		pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
		goto out;
	}

	/* Read the package metadata directory and comprare all installed packages with ones in the cache */
	pkg_metadata_dir = g_file_new_for_path("/var/log/packages");
	pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name",
														 G_FILE_QUERY_INFO_NONE,
														 NULL,
														 &err);
	g_object_unref(pkg_metadata_dir);
	if (err) {
		pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "/var/log/packages: %s", err->message);
		g_error_free(err);
		goto out;
	}

	while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, NULL, NULL))) {
		pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info);
		pkg_tokens = katja_cut_pkg(pkg_metadata_filename);

		/* Select the package from the database */
		sqlite3_bind_text(stmt, 1, pkg_tokens[0], -1, SQLITE_TRANSIENT);

		/* If there are more packages with the same name, remember the one from the repository with the lowest order */
		if ((sqlite3_step(stmt) == SQLITE_ROW) ||
			g_slist_find_custom(repos, ((gchar *) sqlite3_column_text(stmt, 4)), katja_cmp_repo)) {

			full_name = g_strdup((gchar *) sqlite3_column_text(stmt, 0));

			if (!g_strcmp0((gchar *) sqlite3_column_text(stmt, 6), "obsolete")) { /* Remove if obsolete */
				pkg_id = pk_package_id_build(pkg_tokens[PK_PACKAGE_ID_NAME],
											 pkg_tokens[PK_PACKAGE_ID_VERSION],
											 pkg_tokens[PK_PACKAGE_ID_ARCH],
											 "obsolete");
				/* TODO:
				 * 1: Use the repository name instead of "obsolete" above and check in pk_backend_update_packages()
				      if the package is obsolete or not
				 * 2: Get description from /var/log/packages, not from the database */
				desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5));

				pk_backend_job_package(job, PK_INFO_ENUM_REMOVING, pkg_id, desc);

				g_free(desc);
				g_free(pkg_id);
			} else if (g_strcmp0(pkg_metadata_filename, full_name)) { /* Update available */
				pkg_id = pk_package_id_build((gchar *) sqlite3_column_text(stmt, 1),
											 (gchar *) sqlite3_column_text(stmt, 2),
											 (gchar *) sqlite3_column_text(stmt, 3),
											 (gchar *) sqlite3_column_text(stmt, 4));
				desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5));

				pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc);

				g_free(desc);
				g_free(pkg_id);
			}
			g_free(full_name);
		}

		sqlite3_clear_bindings(stmt);
		sqlite3_reset(stmt);

		g_strfreev(pkg_tokens);
		g_object_unref(pkg_metadata_file_info);
	}
	g_object_unref(pkg_metadata_enumerator);

out:
	sqlite3_finalize(stmt);

	pk_backend_job_finished (job);
}
コード例 #22
0
ファイル: sqlite3todot.c プロジェクト: chunky/sqlite3todot
int main(int argc, char **argv) {
	if(argc < 2 || 0 == strcmp(argv[1],"--help") || 0 == strcmp(argv[1], "-h")) {
		fprintf(stderr, "Usage: %s <dbname> [metadb]\n", argv[0]);
		exit(1);
	}

	sqlite3 *db = NULL;
	int rc;
	char *dbname = argv[1];
	rc = sqlite3_open_v2(dbname, &db, SQLITE_OPEN_READONLY, NULL);
	if(SQLITE_OK != rc) {
		fprintf(stderr, "Can't open database %s (%i): %s\n", dbname, rc, sqlite3_errmsg(db));
		sqlite3_close(db);
		exit(1);
	}

	int have_meta = 0;
	if(argc > 2) {
		char attach_sql[1024];
		char *exec_errmsg;
		snprintf(attach_sql,sizeof(attach_sql),"ATTACH \"%s\" AS meta", argv[2]);
		rc = sqlite3_exec(db, attach_sql, NULL, NULL, &exec_errmsg);
		if(SQLITE_OK != rc) {
			fprintf(stderr, "Error attaching meta db (%i): %s\n", rc, exec_errmsg);
			sqlite3_free(exec_errmsg);
			sqlite3_close(db);
			exit(1);
		}
		have_meta = 1;
	}

	const char *tbl_list_sql = "SELECT tbl_name,NULL AS label,NULL AS color,NULL AS clusterid "
		"FROM sqlite_master WHERE type='table'";
	if(have_meta) {
		tbl_list_sql = "SELECT sqlite_master.tbl_name AS tbl_name, meta.cluster.label AS label, meta.cluster.color AS color, meta.cluster.clusterid AS clusterid \n"
			"FROM sqlite_master \n"
			"LEFT JOIN meta.tbl_cluster ON sqlite_master.tbl_name=meta.tbl_cluster.tbl_name \n"
			"LEFT JOIN meta.cluster ON meta.tbl_cluster.clusterid=meta.cluster.clusterid \n"
			"LEFT JOIN meta.ignorelist ON sqlite_master.tbl_name=meta.ignorelist.tbl_name \n"
			"WHERE meta.ignorelist.tbl_name IS NULL \n"
			"       AND main.sqlite_master.type='table'\n"
			"GROUP BY sqlite_master.tbl_name\n"
			"ORDER BY meta.cluster.clusterid\n";
	}
	sqlite3_stmt *tbl_list_stmt;

	// fprintf(stderr, "%s\n", tbl_list_sql);

	rc = sqlite3_prepare_v2(db, tbl_list_sql, -1, &tbl_list_stmt, NULL);
	if(SQLITE_OK != rc) {
		fprintf(stderr, "Can't prepare table list statement (%i): %s\n", rc, sqlite3_errmsg(db));
		sqlite3_close(db);
		exit(1);
	}

	printf("digraph sqliteschema {\n");
	printf("node [shape=plaintext];\n");

	if(have_meta) {
		const char settings_sql[] = "SELECT setting FROM meta.graphsettings";
		sqlite3_stmt *settings_stmt;
		rc = sqlite3_prepare_v2(db, settings_sql, -1, &settings_stmt, NULL);
		if(SQLITE_OK != rc) {
			fprintf(stderr, "Warning: Cannot find meta.graphsettings (%i): %s\n", rc, sqlite3_errmsg(db));
		} else {
			while(SQLITE_ROW == (rc = sqlite3_step(settings_stmt))) {
				printf("%s\n", sqlite3_column_text(settings_stmt,0));
			}
			sqlite3_finalize(settings_stmt);
		}
	} else {
		printf("rankdir=LR\n");
		printf("splines=true\n");
		printf("overlap=scale\n");
	}

	const int cols = 4;

	int curr_cluster = -1;
	while(SQLITE_ROW == (rc = sqlite3_step(tbl_list_stmt))) {
		const char *tbl_name = (char *)sqlite3_column_text(tbl_list_stmt, 0);

		int cluster_id = SQLITE_NULL==sqlite3_column_type(tbl_list_stmt,3)?-1:sqlite3_column_int(tbl_list_stmt,3);
		if(cluster_id != curr_cluster && curr_cluster != -1) {
			printf("}\n");
		}
		if(cluster_id != curr_cluster && cluster_id != -1) {
			printf("subgraph cluster_%i {\n", cluster_id);
			if(SQLITE_NULL!=sqlite3_column_type(tbl_list_stmt,1)) {
				printf("label=\"%s\"\n", sqlite3_column_text(tbl_list_stmt,1));
			}
			if(SQLITE_NULL!=sqlite3_column_type(tbl_list_stmt,2)) {
				printf("color=\"%s\"\n", sqlite3_column_text(tbl_list_stmt,2));
			}
		}
		curr_cluster=cluster_id;

		char *tbl_info_sql = sqlite3_mprintf("PRAGMA table_info(%q)", tbl_name);
		sqlite3_stmt *tbl_info_stmt;

		rc = sqlite3_prepare_v2(db, tbl_info_sql, -1, &tbl_info_stmt, NULL);
		if(SQLITE_OK != rc) {
			fprintf(stderr, "Can't prepare table info statement on table %s (%i): %s\n", tbl_name, rc, sqlite3_errmsg(db));
			sqlite3_close(db);
			exit(1);
		}

		printf("%s [label=<<TABLE CELLSPACING=\"0\"><TR><TD COLSPAN=\"%i\"><U>%s</U></TD></TR>", tbl_name, cols, tbl_name);
		int curr_row = 0;
		int in_brace = 0;
		while(SQLITE_ROW == (rc = sqlite3_step(tbl_info_stmt))) {
			if(0 == curr_row%cols) {
				in_brace = 1;
				printf("<TR>");
			}
			printf("<TD PORT=\"%s\">%s</TD>",
				sqlite3_column_text(tbl_info_stmt, 1),
				sqlite3_column_text(tbl_info_stmt, 1));
			curr_row++;
			if(0 == curr_row%cols) {
				in_brace = 0;
				printf("</TR>");
			}
		}
		if(in_brace) {
			printf("</TR>");
		}
		printf("</TABLE>>];\n");

		sqlite3_free(tbl_info_sql);
		sqlite3_finalize(tbl_info_stmt);

	}
	if(curr_cluster != -1) {
		printf("}\n");
	}

	sqlite3_reset(tbl_list_stmt);
	while(SQLITE_ROW == (rc = sqlite3_step(tbl_list_stmt))) {
		const char *tbl_name = (char *)sqlite3_column_text(tbl_list_stmt, 0);

		char *fkey_info_sql = sqlite3_mprintf("PRAGMA foreign_key_list(%q)", tbl_name);
		sqlite3_stmt *fkey_info_stmt;

		rc = sqlite3_prepare_v2(db, fkey_info_sql, -1, &fkey_info_stmt, NULL);
		if(SQLITE_OK != rc) {
			fprintf(stderr, "Can't prepare foreign key statement on table %s (%i): %s\n", tbl_name, rc, sqlite3_errmsg(db));
			sqlite3_close(db);
			exit(1);
		}

		while(SQLITE_ROW == (rc = sqlite3_step(fkey_info_stmt))) {
			printf("%s:%s -> %s:%s;\n",
				tbl_name,
				sqlite3_column_text(fkey_info_stmt, 3),
				sqlite3_column_text(fkey_info_stmt, 2),
				sqlite3_column_text(fkey_info_stmt, 4));
		}

		sqlite3_free(fkey_info_sql);
		sqlite3_finalize(fkey_info_stmt);
	}

	printf("}\n");

	sqlite3_finalize(tbl_list_stmt);
	sqlite3_close(db);

	return 0;
}
コード例 #23
0
ファイル: SQLite.cpp プロジェクト: Xaymar/BlitzUtility
DLL_FUNCTION(const char*) BU_SQLite_Column_Text(sqlite3_stmt* pStmt, int32_t iCol) {
#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Text=_BU_SQLite_Column_Text@8")
	return (const char*)sqlite3_column_text(pStmt, iCol);
}
コード例 #24
0
ファイル: dbtoshm.c プロジェクト: myth9499/ups
int load_commmsg_cfg(char *table)
{
	key_t	key;
	int shmid,i=0;
	_commmsg *cmsg=NULL;
	size_t shmsize;


	/** init commmsg **/
	shmsize=MAXCOMMMSG*sizeof(_commmsg);
	if((shmid=getshmid(9,shmsize))==-1)
	{
		SysLog(LOG_SYS_ERR,"获取共享内存失败\n");
		return -1;
	}
	SysLog(LOG_SYS_SHOW,"开始加载配置文件\n");
	cmsg = (_commmsg *)shmat(shmid,NULL,0);
	if(cmsg == NULL)
	{
		SysLog(LOG_SYS_ERR,"链接共享内存失败\n");
		return -1;
	}

	sprintf(sql,"%s %s","select * from ",table);
	rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);  
	if (rc != SQLITE_OK)  
	{  
		fprintf(stderr, "%s : %s\n", sql, sqlite3_errmsg(db));    
		sqlite3_close(db);    
		return -1;    
	}  

	ncolumn = sqlite3_column_count(stmt);
	while (sqlite3_step(stmt) == SQLITE_ROW)  
	{     
		for(i = 0 ; i < ncolumn ; i++ )  
		{  
			vtype = sqlite3_column_type(stmt , i);  
			column_name = sqlite3_column_name(stmt , i);  
			switch( vtype )  
			{  
				case SQLITE_NULL:  
					fprintf(stdout, "%s: null\n", column_name);     
					break;  
				case SQLITE_INTEGER:  
					fprintf(stdout, "%s: %d\n", column_name,sqlite3_column_int(stmt,i));    
					break;  
				case SQLITE_FLOAT:  
					fprintf(stdout, "%s: %f\n", column_name,sqlite3_column_double(stmt,i));     
					break;  
				case SQLITE_BLOB: /* arguably fall through... */  
					fprintf(stdout, "%s: BLOB\n", column_name);     
					break;  
				case SQLITE_TEXT:   
					fprintf(stdout, "%s: %s\n", column_name,sqlite3_column_text(stmt,i));   
					break;  
				default:  
					fprintf(stdout, "%s: ERROR [%s]\n", column_name, sqlite3_errmsg(db));   
					break;  
			}
			if(i==1)
			{	
				strcpy(cmsg->commname,sqlite3_column_text(stmt,i));
			}
			if(i==2)
			{
				cmsg->len=sqlite3_column_int(stmt,i);
			}	
			if(i==3)
			{
				strcpy(cmsg->commvar,sqlite3_column_text(stmt,i));
			}	
			if(i==4)
			{
				strcpy(cmsg->commmark,sqlite3_column_text(stmt,i));
			}	
		}  
		cmsg++;
	}
	SysLog(LOG_SYS_SHOW,"加载配置文件成功\n");
	shmdt(cmsg);
	return 0;
}
コード例 #25
0
ファイル: db_sqlite.c プロジェクト: gureedo/ed2kd
int db_search_files(struct search_node *snode, struct evbuffer *buf, size_t *count)
{
    int err;
    const char *tail;
    sqlite3_stmt *stmt = 0;
    size_t i;
    struct {
        char name_term[MAX_NAME_TERM_LEN + 1];
        size_t name_len;
        uint64_t minsize;
        uint64_t maxsize;
        uint64_t srcavail;
        uint64_t srccomplete;
        uint64_t minbitrate;
        uint64_t minlength;
        struct search_node *ext_node;
        struct search_node *codec_node;
        struct search_node *type_node;
    } params;
    char query[MAX_SEARCH_QUERY_LEN + 1] =
            " SELECT f.hash,f.name,f.size,f.type,f.ext,f.srcavail,f.srccomplete,f.rating,f.rated_count,"
                    "  (SELECT sid FROM sources WHERE fid=f.fid LIMIT 1) AS sid,"
                    "  f.mlength,f.mbitrate,f.mcodec "
                    " FROM fnames n"
                    " JOIN files f ON f.fid = n.docid"
                    " WHERE fnames MATCH ?";

    memset(&params, 0, sizeof params);

    while (snode) {
        if ((ST_AND <= snode->type) && (ST_NOT >= snode->type)) {
            if (!snode->left_visited) {
                if (snode->string_term) {
                    params.name_len++;
                    DB_CHECK(params.name_len < sizeof params.name_term);
                    strcat(params.name_term, "(");
                }
                snode->left_visited = 1;
                snode = snode->left;
                continue;
            } else if (!snode->right_visited) {
                if (snode->string_term) {
                    const char *oper = 0;
                    switch (snode->type) {
                        case ST_AND:
                            params.name_len += 5;
                            oper = " AND ";
                            break;
                        case ST_OR:
                            params.name_len += 4;
                            oper = " OR ";
                            break;
                        case ST_NOT:
                            params.name_len += 5;
                            oper = " NOT ";
                            break;

                        default:
                            DB_CHECK(0);
                    }
                    DB_CHECK(params.name_len < sizeof params.name_term);
                    strcat(params.name_term, oper);
                }
                snode->right_visited = 1;
                snode = snode->right;
                continue;
            } else {
                if (snode->string_term) {
                    params.name_len++;
                    DB_CHECK(params.name_len < sizeof params.name_term);
                    strcat(params.name_term, ")");
                }
            }
        } else {
            switch (snode->type) {
                case ST_STRING:
                    params.name_len += snode->str_len;
                    DB_CHECK(params.name_len < sizeof params.name_term);
                    strncat(params.name_term, snode->str_val, snode->str_len);
                    break;
                case ST_EXTENSION:
                    params.ext_node = snode;
                    break;
                case ST_CODEC:
                    params.codec_node = snode;
                    break;
                case ST_MINSIZE:
                    params.minsize = snode->int_val;
                    break;
                case ST_MAXSIZE:
                    params.maxsize = snode->int_val;
                    break;
                case ST_SRCAVAIL:
                    params.srcavail = snode->int_val;
                    break;
                case ST_SRCCOMLETE:
                    params.srccomplete = snode->int_val;
                    break;
                case ST_MINBITRATE:
                    params.minbitrate = snode->int_val;
                    break;
                case ST_MINLENGTH:
                    params.minlength = snode->int_val;
                    break;
                case ST_TYPE:
                    params.type_node = snode;
                    break;
                default:
                    DB_CHECK(0);
            }
        }

        snode = snode->parent;
    }

    if (params.ext_node) {
        strcat(query, " AND f.ext=?");
    }
    if (params.codec_node) {
        strcat(query, " AND f.mcodec=?");
    }
    if (params.minsize) {
        strcat(query, " AND f.size>?");
    }
    if (params.maxsize) {
        strcat(query, " AND f.size<?");
    }
    if (params.srcavail) {
        strcat(query, " AND f.srcavail>?");
    }
    if (params.srccomplete) {
        strcat(query, " AND f.srccomplete>?");
    }
    if (params.minbitrate) {
        strcat(query, " AND f.mbitrate>?");
    }
    if (params.minlength) {
        strcat(query, " AND f.mlength>?");
    }
    if (params.type_node) {
        strcat(query, " AND f.type=?");
    }
    strcat(query, " LIMIT ?");

    DB_CHECK(SQLITE_OK == sqlite3_prepare_v2(s_db, query, strlen(query) + 1, &stmt, &tail));

    i = 1;
    DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, params.name_term, params.name_len + 1, SQLITE_STATIC));

    if (params.ext_node) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, params.ext_node->str_val, params.ext_node->str_len, SQLITE_STATIC));
    }
    if (params.codec_node) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_text(stmt, i++, params.codec_node->str_val, params.codec_node->str_len, SQLITE_STATIC));
    }
    if (params.minsize) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, params.minsize));
    }
    if (params.maxsize) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, params.maxsize));
    }
    if (params.srcavail) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, params.srcavail));
    }
    if (params.srccomplete) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, params.srccomplete));
    }
    if (params.minbitrate) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, params.minbitrate));
    }
    if (params.minlength) {
        DB_CHECK(SQLITE_OK == sqlite3_bind_int64(stmt, i++, params.minlength));
    }
    if (params.type_node) {
        uint8_t type = get_ed2k_file_type(params.type_node->str_val, params.type_node->str_len);
        DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, type));
    }

    DB_CHECK(SQLITE_OK == sqlite3_bind_int(stmt, i++, *count));

    i = 0;
    while (((err = sqlite3_step(stmt)) == SQLITE_ROW) && (i < *count)) {
        struct search_file sfile;
        uint64_t sid;
        int col = 0;

        memset(&sfile, 0, sizeof sfile);

        sfile.hash = (const unsigned char *) sqlite3_column_blob(stmt, col++);

        sfile.name_len = sqlite3_column_bytes(stmt, col);
        sfile.name_len = sfile.name_len > MAX_FILENAME_LEN ? MAX_FILENAME_LEN : sfile.name_len;
        sfile.name = (const char *) sqlite3_column_text(stmt, col++);

        sfile.size = sqlite3_column_int64(stmt, col++);
        sfile.type = sqlite3_column_int(stmt, col++);

        sfile.ext_len = sqlite3_column_bytes(stmt, col);
        sfile.ext_len = sfile.ext_len > MAX_FILEEXT_LEN ? MAX_FILEEXT_LEN : sfile.ext_len;
        sfile.ext = (const char *) sqlite3_column_text(stmt, col++);

        sfile.srcavail = sqlite3_column_int(stmt, col++);
        sfile.srccomplete = sqlite3_column_int(stmt, col++);
        sfile.rating = sqlite3_column_int(stmt, col++);
        sfile.rated_count = sqlite3_column_int(stmt, col++);

        sid = sqlite3_column_int64(stmt, col++);
        sfile.client_id = GET_SID_ID(sid);
        sfile.client_port = GET_SID_PORT(sid);

        sfile.media_length = sqlite3_column_int(stmt, col++);
        sfile.media_bitrate = sqlite3_column_int(stmt, col++);

        sfile.media_codec_len = sqlite3_column_bytes(stmt, col);
        sfile.media_codec_len = sfile.media_codec_len > MAX_FILEEXT_LEN ? MAX_FILEEXT_LEN : sfile.media_codec_len;
        sfile.media_codec = (const char *) sqlite3_column_text(stmt, col++);

        write_search_file(buf, &sfile);

        ++i;
    }

    DB_CHECK((i == *count) || (SQLITE_DONE == err));

    *count = i;
    return 1;

    failed:
    if (stmt) sqlite3_finalize(stmt);
    ED2KD_LOGERR("failed perform search query (%s)", sqlite3_errmsg(s_db));

    return 0;
}
コード例 #26
0
ファイル: dbtoshm.c プロジェクト: myth9499/ups
int load_flow_cfg(char *table)
{
	key_t	key;
	int i=0,shmid;
	_flow *flow=NULL;
	size_t shmsize;


	/** init commmsg **/
	shmsize=MAXFLOW*sizeof(_flow);
	if((shmid=getshmid(8,shmsize))==-1)
	{
		SysLog(LOG_SYS_ERR,"获取流程配置共享内存失败\n");
		return -1;
	}
	SysLog(LOG_SYS_SHOW,"开始装载流程配置表[%s]\n",table);
	flow = (_flow *)shmat(shmid,NULL,0);
	if(flow == NULL)
	{
		SysLog(LOG_SYS_ERR,"链接流程配置共享内存失败\n");
		return -1;
	}
	sprintf(sql,"%s %s","select * from ",table);
	rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);  
	if (rc != SQLITE_OK)  
	{  
		fprintf(stderr, "%s : %s\n", sql, sqlite3_errmsg(db));    
		sqlite3_close(db);    
		return -1;    
	}  

	ncolumn = sqlite3_column_count(stmt);
	while (sqlite3_step(stmt) == SQLITE_ROW)  
	{     
		for(i = 0 ; i < ncolumn ; i++ )  
		{  
			vtype = sqlite3_column_type(stmt , i);  
			column_name = sqlite3_column_name(stmt , i);  
			switch( vtype )  
			{  
				case SQLITE_NULL:  
					fprintf(stdout, "%s: null\n", column_name);     
					break;  
				case SQLITE_INTEGER:  
					fprintf(stdout, "%s: %d\n", column_name,sqlite3_column_int(stmt,i));    
					break;  
				case SQLITE_FLOAT:  
					fprintf(stdout, "%s: %f\n", column_name,sqlite3_column_double(stmt,i));     
					break;  
				case SQLITE_BLOB: /* arguably fall through... */  
					fprintf(stdout, "%s: BLOB\n", column_name);     
					break;  
				case SQLITE_TEXT:   
					fprintf(stdout, "%s: %s\n", column_name,sqlite3_column_text(stmt,i));   
					break;  
				default:  
					fprintf(stdout, "%s: ERROR [%s]\n", column_name, sqlite3_errmsg(db));   
					break;  
			}
			if(i==1)
				strcpy(flow->flowname,sqlite3_column_text(stmt,i));
			if(i==2)
				strcpy(flow->flowmark,sqlite3_column_text(stmt,i));
			if(i==3)
				strcpy(flow->flowso,sqlite3_column_text(stmt,i));
			if(i==4)
				strcpy(flow->flowfunc,sqlite3_column_text(stmt,i));
			if(i==5)
				strcpy(flow->funcpar1,sqlite3_column_text(stmt,i));
			if(i==6)
				strcpy(flow->errflow,sqlite3_column_text(stmt,i));
		}
		flow++;
	}
	shmdt(flow);
	SysLog(LOG_SYS_SHOW,"装载流程配置表[%s]成功\n",table);
	return 0;
}
コード例 #27
0
ファイル: load.c プロジェクト: Pankajumn/disambig
static int build_record(sqlite3_stmt *ppStmt, DbRecord *recordp, struct sqlite_workspace* w){
    int i, j, cols = sqlite3_column_count(ppStmt); 
    char *num_delim = "~";
    char *element_delim= "/";
    char *w_buf;
    char *out_ptr, *in_ptr;

    if(*(w->count) == 36781)
        printf("ha!\n");

    for(i = 0, w->f = fieldlist; i < cols && w->f->name != NULL; (w->f)++, i++){
        //switch(sqlite3_column_type(ppStmt, i)){
        if(w->f->array){
            j=0;
            memcpy(w->buf, sqlite3_column_text(ppStmt, i), sqlite3_column_bytes(ppStmt, i)+1);
            w_buf = w->buf;
            while((out_ptr=strsep(&(w_buf), element_delim)) != NULL){
                if(j >= w->f->array_len)
                    break;
                in_ptr=strsep(&out_ptr, num_delim);
                switch(w->f->type){
                    case UNSIGNED_LONG:
                        *(((int*)((char*)recordp+(w->f->offset)))+j) = atoi(in_ptr);
                        break;
                    case STRING:
                        memcpy((char*)recordp+(w->f->offset)+(j*(w->f->size)), in_ptr,
                                MIN(w->f->size-1, strlen(in_ptr)+1));
                        if(strlen(in_ptr)+1 > w->f->size)
                            *((char*)recordp+(w->f->offset)+(j*(w->f->size))+(w->f->size)-1) = '\0';
                        //if(j > 1)
                        //    printf("%s\n", in_ptr);
                        break;
                    case DATE:
                        strptime(in_ptr, "%Y%m%d", ((struct tm*)((char*)recordp+(w->f->offset)))+j);
                        break;
                    case DOUBLE:
                        *(((double*)((char*)recordp+(w->f->offset)))+j) = strtod(in_ptr, NULL);
                        break;
                    default:
                        abort();
                }
                ++j;
            }
            //if(j+1 < w->f->array_len)
                
        }

        else{    
            switch(w->f->type){
                case UNSIGNED_LONG:
                    *(int*)((char*)recordp+(w->f->offset)) = sqlite3_column_int(ppStmt, i);
                    break;
                case STRING:
                    //printf("%lu\n", *(w->count));
                    //if(*(w->count) > 36781)
                    //    printf("%s\n", sqlite3_column_text(ppStmt, i));
                    memcpy((char*)recordp+(w->f->offset), sqlite3_column_text(ppStmt, i),
                            MIN(w->f->size-1,sqlite3_column_bytes(ppStmt, i)));
                    *((char*)recordp+(w->f->offset)+MIN(w->f->size-1, sqlite3_column_bytes(ppStmt, i))) = '\0';
                    break;
                case DATE:
                    strptime((char*)sqlite3_column_text(ppStmt, i), "%Y%m%d", 
                            (struct tm*)((char*)recordp+(w->f->offset)));
                    break;
                case DOUBLE:
                    *(double*)((char*)recordp+(w->f->offset)) = sqlite3_column_double(ppStmt, i);
                    break;
                default:
                    abort();
            }
        }
    }
    if(i < cols){
        printf("Description file has fewer slots than sqlite query columns.");
        abort();
    }
    if(w->f->name != NULL){
        printf("Description file has more slots that sqlite query columns.");
        abort();
    }

    return(0);
}
コード例 #28
0
ファイル: dbtoshm.c プロジェクト: myth9499/ups
int load_xmlcfg(char *xmltype,char *table)
{
	int  i = 0;
	_xmlcfg *xmlcfg = NULL;

	int shmid = 0;
	size_t shmsize = MAXXMLCFG*sizeof(_xmlcfg);

	SysLog(LOG_SYS_SHOW,"开始装载XML配置表[%s]\n",table);
	if((shmid = getshmid(6,shmsize))==-1)
	{
		SysLog(LOG_SYS_ERR,"获取XML配置共享内存失败\n");
		return -1;
	}
	if((xmlcfg = shmat(shmid,NULL,0))==(void *)-1)
	{
		SysLog(LOG_SYS_ERR,"链接XML配置共享内存失败\n");
		return -1;
	}
	sprintf(sql,"%s %s","select * from ",table);
	rc = sqlite3_prepare_v2(db, sql, -1, &stmt, 0);  
	if (rc != SQLITE_OK)  
	{  
		fprintf(stderr, "%s : %s\n", sql, sqlite3_errmsg(db));    
		sqlite3_close(db);    
		return -1;    
	}  

	ncolumn = sqlite3_column_count(stmt);
	while (sqlite3_step(stmt) == SQLITE_ROW)  
	{     
		for(i = 0 ; i < ncolumn ; i++ )  
		{  
			vtype = sqlite3_column_type(stmt , i);  
			column_name = sqlite3_column_name(stmt , i);  
			switch( vtype )  
			{  
				case SQLITE_NULL:  
					fprintf(stdout, "%s: null\n", column_name);     
					break;  
				case SQLITE_INTEGER:  
					fprintf(stdout, "%s: %d\n", column_name,sqlite3_column_int(stmt,i));    
					break;  
				case SQLITE_FLOAT:  
					fprintf(stdout, "%s: %f\n", column_name,sqlite3_column_double(stmt,i));     
					break;  
				case SQLITE_BLOB: /* arguably fall through... */  
					fprintf(stdout, "%s: BLOB\n", column_name);     
					break;  
				case SQLITE_TEXT:   
					fprintf(stdout, "%s: %s\n", column_name,sqlite3_column_text(stmt,i));   
					break;  
				default:  
					fprintf(stdout, "%s: ERROR [%s]\n", column_name, sqlite3_errmsg(db));   
					break;  
			}
			if(i==1)
				strcpy(xmlcfg->xmlname,sqlite3_column_text(stmt,i));
			if(i==2)
				strcpy(xmlcfg->mark,sqlite3_column_text(stmt,i));
			if(i==3)
				strcpy(xmlcfg->fullpath,sqlite3_column_text(stmt,i));
			if(i==4)
				strcpy(xmlcfg->varname,sqlite3_column_text(stmt,i));
			if(i==5)
				strcpy(xmlcfg->isneed,sqlite3_column_text(stmt,i));
			if(i==6)
				strcpy(xmlcfg->sign,sqlite3_column_text(stmt,i));
			if(i==7)
				strcpy(xmlcfg->loop,sqlite3_column_text(stmt,i));
			if(i==7)
				xmlcfg->depth=sqlite3_column_int(stmt,i);
		}
		xmlcfg++;
	}
	shmdt(xmlcfg);
	SysLog(LOG_SYS_SHOW,"装载XML配置表[%s]成功\n",table);
	return  0;
}
コード例 #29
0
/* public native void dbopen(String path, int flags, String locale); */
static void dbopen(JNIEnv* env, jobject object, jstring pathString, jint flags)
{
    int err;
    sqlite3 * handle = NULL;
    sqlite3_stmt * statement = NULL;
    char const * path8 = env->GetStringUTFChars(pathString, NULL);
    int sqliteFlags;
    // Error code handling for SQLite exec
    char* zErrMsg = NULL;

    // register the logging func on sqlite. needs to be done BEFORE any sqlite3 func is called.
    registerLoggingFunc(path8);

    // convert our flags into the sqlite flags
    if (flags & CREATE_IF_NECESSARY) {
        sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
    } else if (flags & OPEN_READONLY) {
        sqliteFlags = SQLITE_OPEN_READONLY;
    } else {
        sqliteFlags = SQLITE_OPEN_READWRITE;
    }

    err = sqlite3_open_v2(path8, &handle, sqliteFlags, NULL);
    if (err != SQLITE_OK) {
        LOGE("sqlite3_open_v2(\"%s\", &handle, %d, NULL) failed\n", path8, sqliteFlags);
        throw_sqlite3_exception(env, handle);
        goto done;
    }

    // WAL is a new rollback method available in SQLite v3.7+. WAL speeds up writes to
    // SQLite databases. WAL cannot be used with Read Only databases or databases opened
    // in read only mode.

    // Check if DB can use WAL mode; Open in WAL mode for non-ReadOnly DBs
    if(!(flags & OPEN_READONLY) && (use_wal_mode(path8))) {
        // Configure databases to run in WAL mode.
        err = sqlite3_exec(handle,"PRAGMA journal_mode = WAL;",
                           NULL, NULL,&zErrMsg);
        if (SQLITE_OK != err) {
           LOGE("sqlite3_exec - Failed to set WAL mode for [%s] \n", path8);
           err = sqlite3_exec(handle,"PRAGMA journal_mode = DELETE;",
                           NULL, NULL,&zErrMsg);
           if(SQLITE_OK != err) {
               LOGE("sqlite3_exec - Failed to set DELETE mode for [%s] \n", path8);
               throw_sqlite3_exception(env, handle);
               goto done;
           }
        }
        else {
            LOGI("WAL succesfuly enabled for [%s] \n", path8);
            // Set autocheckpoint = 100 pages
            err = sqlite3_wal_autocheckpoint(handle,
                                             100);
            if (SQLITE_OK != err) {
               LOGE("sqlite3_exec to set WAL autocheckpoint failed\n");
               throw_sqlite3_exception(env, handle);
               goto done;
            } else if (use_wal_mode(path8) == 2) {
                /* Try to disable fsyncs. We don't care if it fails */
                sqlite3_exec(handle,"PRAGMA synchronous = OFF;",
                           NULL, NULL,&zErrMsg);
            }
        }
    }

    // The soft heap limit prevents the page cache allocations from growing
    // beyond the given limit, no matter what the max page cache sizes are
    // set to. The limit does not, as of 3.5.0, affect any other allocations.
    sqlite3_soft_heap_limit(SQLITE_SOFT_HEAP_LIMIT);

    // Set the default busy handler to retry for 1000ms and then return SQLITE_BUSY
    err = sqlite3_busy_timeout(handle, 1000 /* ms */);
    if (err != SQLITE_OK) {
        LOGE("sqlite3_busy_timeout(handle, 1000) failed for \"%s\"\n", path8);
        throw_sqlite3_exception(env, handle);
        goto done;
    }

#ifdef DB_INTEGRITY_CHECK
    static const char* integritySql = "pragma integrity_check(1);";
    err = sqlite3_prepare_v2(handle, integritySql, -1, &statement, NULL);
    if (err != SQLITE_OK) {
        LOGE("sqlite_prepare_v2(handle, \"%s\") failed for \"%s\"\n", integritySql, path8);
        throw_sqlite3_exception(env, handle);
        goto done;
    }

    // first is OK or error message
    err = sqlite3_step(statement);
    if (err != SQLITE_ROW) {
        LOGE("integrity check failed for \"%s\"\n", integritySql, path8);
        throw_sqlite3_exception(env, handle);
        goto done;
    } else {
        const char *text = (const char*)sqlite3_column_text(statement, 0);
        if (strcmp(text, "ok") != 0) {
            LOGE("integrity check failed for \"%s\": %s\n", integritySql, path8, text);
            jniThrowException(env, "android/database/sqlite/SQLiteDatabaseCorruptException", text);
            goto done;
        }
    }
#endif

    err = register_android_functions(handle, UTF16_STORAGE);
    if (err) {
        throw_sqlite3_exception(env, handle);
        goto done;
    }

    LOGV("Opened '%s' - %p\n", path8, handle);
    env->SetIntField(object, offset_db_handle, (int) handle);
    handle = NULL;  // The caller owns the handle now.

done:
    // Release allocated resources
    if (path8 != NULL) env->ReleaseStringUTFChars(pathString, path8);
    if (statement != NULL) sqlite3_finalize(statement);
    if (handle != NULL) sqlite3_close(handle);
}
static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window,
        sqlite3_stmt* statement, int numColumns, int startPos, int addedRows) {
    // Allocate a new field directory for the row.
    status_t status = window->allocRow();
    if (status) {
        LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
                startPos, addedRows, status);
        return CPR_FULL;
    }

    // Pack the row into the window.
    CopyRowResult result = CPR_OK;
    for (int i = 0; i < numColumns; i++) {
        int type = sqlite3_column_type(statement, i);
        if (type == SQLITE_TEXT) {
            // TEXT data
            const char* text = reinterpret_cast<const char*>(
                    sqlite3_column_text(statement, i));
            // SQLite does not include the NULL terminator in size, but does
            // ensure all strings are NULL terminated, so increase size by
            // one to make sure we store the terminator.
            size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
            status = window->putString(addedRows, i, text, sizeIncludingNull);
            if (status) {
                LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
                        sizeIncludingNull, startPos + addedRows, i, status);
                result = CPR_FULL;
                break;
            }
            LOG_WINDOW("%d,%d is TEXT with %u bytes",
                    startPos + addedRows, i, sizeIncludingNull);
        } else if (type == SQLITE_INTEGER) {
            // INTEGER data
            int64_t value = sqlite3_column_int64(statement, i);
            status = window->putLong(addedRows, i, value);
            if (status) {
                LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
                        i, status);
                result = CPR_FULL;
                break;
            }
            LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + addedRows, i, value);
        } else if (type == SQLITE_FLOAT) {
            // FLOAT data
            double value = sqlite3_column_double(statement, i);
            status = window->putDouble(addedRows, i, value);
            if (status) {
                LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
                        i, status);
                result = CPR_FULL;
                break;
            }
            LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
        } else if (type == SQLITE_BLOB) {
            // BLOB data
            const void* blob = sqlite3_column_blob(statement, i);
            size_t size = sqlite3_column_bytes(statement, i);
            status = window->putBlob(addedRows, i, blob, size);
            if (status) {
                LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
                        size, startPos + addedRows, i, status);
                result = CPR_FULL;
                break;
            }
            LOG_WINDOW("%d,%d is Blob with %u bytes",
                    startPos + addedRows, i, size);
        } else if (type == SQLITE_NULL) {
            // NULL field
            status = window->putNull(addedRows, i);
            if (status) {
                LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
                        i, status);
                result = CPR_FULL;
                break;
            }

            LOG_WINDOW("%d,%d is NULL", startPos + addedRows, i);
        } else {
            // Unknown data
            ALOGE("Unknown column type when filling database window");
            throw_sqlite3_exception(env, "Unknown column type when filling window");
            result = CPR_ERROR;
            break;
        }
    }

    // Free the last row if if was not successfully copied.
    if (result != CPR_OK) {
        window->freeLastRow();
    }
    return result;
}