void caja_column_chooser_get_settings (CajaColumnChooser *chooser, char ***visible_columns, char ***column_order) { g_return_if_fail (CAJA_IS_COLUMN_CHOOSER (chooser)); g_return_if_fail (visible_columns != NULL); g_return_if_fail (column_order != NULL); *visible_columns = get_column_names (chooser, TRUE); *column_order = get_column_names (chooser, FALSE); }
void nautilus_column_chooser_get_settings (NautilusColumnChooser *chooser, char ***visible_columns, char ***column_order) { g_return_if_fail (NAUTILUS_IS_COLUMN_CHOOSER (chooser)); g_return_if_fail (visible_columns != NULL); g_return_if_fail (column_order != NULL); *visible_columns = get_column_names (chooser, TRUE); *column_order = get_column_names (chooser, FALSE); }
SQLRETURN CLMoreResults( SQLHSTMT statement_handle ) { CLHSTMT cl_statement = (CLHSTMT) statement_handle; SQLRETURN ret; ret = SQLMORERESULTS( cl_statement -> cl_connection, cl_statement -> driver_stmt ); if ( SQL_SUCCEEDED( ret )) { SQLSMALLINT column_count; ret = SQLNUMRESULTCOLS( cl_statement -> cl_connection, cl_statement -> driver_stmt, &column_count ); cl_statement -> column_count = column_count; cl_statement -> first_fetch_done = 0; if ( column_count > 0 ) { ret = get_column_names( cl_statement ); } } return ret; }
size_t O2DatDB:: select(const wchar_t *sql, SQLResultList &out) { #if TRACE_SQL_EXEC_TIME stopwatch sw("select"); #endif wstrarray cols; sqlite3 *db = NULL; int err = sqlite3_open16(dbfilename.c_str(), &db); if (err != SQLITE_OK) goto error; sqlite3_busy_timeout(db, 5000); sqlite3_stmt *stmt = NULL; err = sqlite3_prepare16_v2(db, sql, wcslen(sql)*2, &stmt, NULL); if (err != SQLITE_OK) goto error; sqlite3_reset(stmt); err = sqlite3_step(stmt); if (err != SQLITE_ROW && err != SQLITE_DONE) goto error; if (out.empty()) { //一行目 cols.clear(); get_column_names(stmt, cols); out.push_back(cols); cols.clear(); get_columns(stmt, cols); out.push_back(cols); } while (sqlite3_step(stmt) == SQLITE_ROW) { //2行目以降 cols.clear(); get_columns(stmt, cols); out.push_back(cols); } sqlite3_finalize(stmt); stmt = NULL; err = sqlite3_close(db); if (err != SQLITE_OK) goto error; return (out.size()); error: log(db); if (stmt) sqlite3_finalize(stmt); if (db) sqlite3_close(db); return (0); }
void create_cluster() { Attribute::register_class_names(get_column_names()); Record * r = make_quuxalot_record(); ClusterHead ch(r, 0.9953); RecordPList rl = get_record_list(); cBlocking_Operation_By_Coauthors blocker_coauthor = get_blocker_coathor(); Cluster::set_reference_patent_tree_pointer( blocker_coauthor.get_patent_tree()); Cluster * c = new Cluster(ch, rl); delete c; }
SQLRETURN CLExecDirect( SQLHSTMT statement_handle, SQLCHAR *statement_text, SQLINTEGER text_length ) { CLHSTMT cl_statement = (CLHSTMT) statement_handle; SQLRETURN ret; /* * save the statement for later use */ if ( cl_statement -> sql_text ) { free( cl_statement -> sql_text ); } if ( text_length < 0 ) { cl_statement -> sql_text = strdup((char*) statement_text ); } else { cl_statement -> sql_text = malloc( text_length + 1 ); memcpy( cl_statement -> sql_text, statement_text, text_length ); cl_statement -> sql_text[ text_length ] = '\0'; } ret = SQLEXECDIRECT( cl_statement -> cl_connection, cl_statement -> driver_stmt, statement_text, text_length ); if ( SQL_SUCCEEDED( ret )) { SQLSMALLINT column_count; ret = SQLNUMRESULTCOLS( cl_statement -> cl_connection, cl_statement -> driver_stmt, &column_count ); cl_statement -> column_count = column_count; cl_statement -> first_fetch_done = 0; if ( column_count > 0 ) { ret = get_column_names( cl_statement ); } } return ret; }
// tests if the columns of TSDB 'table' match the datapoint type T // returns false if 'table' does not have the columns necessary for required datatype template<typename T> bool _columns_match_type(const std::string& table) { BOOST_STATIC_ASSERT((boost::is_base_of< dp::DataPoint, T>::value)); std::vector<std::string> columns = get_column_names( table ); std::vector<std::string> t_columns = dp::dp_names<T>(); std::sort(columns.begin(),columns.end()); std::sort(t_columns.begin(),t_columns.end()); if( !includes(columns.begin(), columns.end(), t_columns.begin(), t_columns.end() ) ) return false; return true; }
SQLRETURN CLColumnPrivileges( SQLHSTMT statement_handle, SQLCHAR *catalog_name, SQLSMALLINT name_length1, SQLCHAR *schema_name, SQLSMALLINT name_length2, SQLCHAR *table_name, SQLSMALLINT name_length3, SQLCHAR *column_name, SQLSMALLINT name_length4 ) { CLHSTMT cl_statement = (CLHSTMT) statement_handle; SQLRETURN ret; ret = SQLCOLUMNPRIVILEGES( cl_statement -> cl_connection, cl_statement -> driver_stmt, catalog_name, name_length1, schema_name, name_length2, table_name, name_length3, column_name, name_length4 ); if ( SQL_SUCCEEDED( ret )) { SQLSMALLINT column_count; ret = SQLNUMRESULTCOLS( cl_statement -> cl_connection, cl_statement -> driver_stmt, &column_count ); cl_statement -> column_count = column_count; cl_statement -> first_fetch_done = 0; cl_statement -> not_from_select = 1; if ( column_count > 0 ) { ret = get_column_names( cl_statement ); } } return ret; }
SQLRETURN CLPrimaryKeys( SQLHSTMT statement_handle, SQLCHAR *sz_catalog_name, SQLSMALLINT cb_catalog_name, SQLCHAR *sz_schema_name, SQLSMALLINT cb_schema_name, SQLCHAR *sz_table_name, SQLSMALLINT cb_table_name ) { CLHSTMT cl_statement = (CLHSTMT) statement_handle; SQLRETURN ret; ret = SQLPRIMARYKEYS( cl_statement -> cl_connection, cl_statement -> driver_stmt, sz_catalog_name, cb_catalog_name, sz_schema_name, cb_schema_name, sz_table_name, cb_table_name ); if ( SQL_SUCCEEDED( ret )) { SQLSMALLINT column_count; ret = SQLNUMRESULTCOLS( cl_statement -> cl_connection, cl_statement -> driver_stmt, &column_count ); cl_statement -> column_count = column_count; cl_statement -> first_fetch_done = 0; cl_statement -> not_from_select = 1; if ( column_count > 0 ) { ret = get_column_names( cl_statement ); } } return ret; }
void extract_sequences(char vcf_filename[], char tree_filename[],char multi_fasta_filename[],int min_snps, char original_multi_fasta_filename[]) { FILE *vcf_file_pointer; vcf_file_pointer=fopen(vcf_filename, "r"); newick_node* root_node; int number_of_snps; int number_of_columns; int i; int length_of_original_genome; length_of_original_genome = genome_length(original_multi_fasta_filename); number_of_columns = get_number_of_columns_from_file(vcf_file_pointer); char* column_names[number_of_columns]; for(i = 0; i < number_of_columns; i++) { column_names[i] = calloc(MAX_SAMPLE_NAME_SIZE,sizeof(char)); } get_column_names(vcf_file_pointer, column_names, number_of_columns); number_of_snps = number_of_snps_in_phylip(); int snp_locations[number_of_snps]; get_integers_from_column_in_vcf(vcf_file_pointer, snp_locations, number_of_snps, column_number_for_column_name(column_names, "POS", number_of_columns)); root_node = build_newick_tree(tree_filename, vcf_file_pointer,snp_locations, number_of_snps, column_names, number_of_columns, length_of_original_genome,min_snps); fclose(vcf_file_pointer); int filtered_snp_locations[number_of_snps]; int number_of_filtered_snps; int number_of_samples = number_of_samples_from_parse_phylip(); char * sample_names[number_of_samples]; get_sample_names_from_parse_phylip(sample_names); char * reference_sequence_bases; reference_sequence_bases = (char *) calloc((number_of_snps+1),sizeof(char)); get_sequence_for_sample_name(reference_sequence_bases, sample_names[0]); int internal_nodes[number_of_samples]; int a = 0; for(a =0; a < number_of_samples; a++) { internal_nodes[a] = get_internal_node(a); } number_of_filtered_snps = refilter_existing_snps(reference_sequence_bases, number_of_snps, snp_locations, filtered_snp_locations,internal_nodes); char * filtered_bases_for_snps[number_of_filtered_snps]; filter_sequence_bases_and_rotate(reference_sequence_bases, filtered_bases_for_snps, number_of_filtered_snps); create_phylip_of_snp_sites(tree_filename, number_of_filtered_snps, filtered_bases_for_snps, sample_names, number_of_samples,internal_nodes); create_vcf_file(tree_filename, filtered_snp_locations, number_of_filtered_snps, filtered_bases_for_snps, sample_names, number_of_samples,internal_nodes,0); create_fasta_of_snp_sites(tree_filename, number_of_filtered_snps, filtered_bases_for_snps, sample_names, number_of_samples,internal_nodes); // Create an new tree with updated distances scale_branch_distances(root_node, number_of_filtered_snps); FILE *output_tree_pointer; output_tree_pointer=fopen(tree_filename, "w"); print_tree(root_node,output_tree_pointer); fprintf(output_tree_pointer,";"); fflush(output_tree_pointer); fclose(output_tree_pointer); // Theres a seg fault in here for(i = 0; i < number_of_columns; i++) { free(column_names[i] ); } for(i=0; i<number_of_samples; i++ ) { free(sample_names[i]); } for(i=0; i<number_of_filtered_snps; i++ ) { free(filtered_bases_for_snps[i]); } cleanup_node_memory(root_node); seqFreeAll(); free(reference_sequence_bases); }
int main_i(const std::vector<std::string> &argv) { int argc = argv.size(); if (argc == 1 || (argc == 2 && argv[1] == "-h")) { std:: cout << "Picosel ver. 1.5 (C) 2009-2010 AIST" "\n" "Usage 1: picosel OPTION from inputfile select column where EXPRESSION" "\n" "Usage 2: picosel OPTION from inputfile select column order by column" "\n" "Option" "\n" " -o outputfile: specify output file." "\n"; return 0; } if (argc == 3 && argv[1] == "--text") { return convert_binary_file_to_text(argv[2]); } int r = analyze_commandline(argv); if (r != 0) { return r; } std:: ifstream input; input.open(fromFile.c_str(), std:: ios::in | std:: ios::binary); if (! input.is_open()) { std:: cerr << "error: can not open file '" << fromFile << "'" << std:: endl; return 1; } std:: istream *pInput = &input; r = get_column_names(pInput); if (r != 0) { return r; } int selectColIndex = findNamedColumn(selectCol); if (selectColIndex == -1) { std:: cerr << "error: unknown column name '" << selectCol << "'" << std:: endl; return 1; } r = check_expression(); if (r != 0) { return r; } std:: ostream *pOutput = &std:: cout; std:: ofstream output; if (! outputFile.empty()) { output.open(outputFile.c_str(), binaryOutputFactor != 0 ? (std:: ios::out | std:: ios::binary) : std:: ios::out); if (! output.is_open()) { std:: cerr << "error: can not create file '" << outputFile << "'" << std:: endl; return 1; } pOutput = &output; } if (! orderByAsc.empty()) { int orderColIndex = findNamedColumn(orderByAsc); if (orderColIndex == -1) { std:: cerr << "error: unknown column name '" << orderByAsc << "'" << std:: endl; return 1; } r = do_sorting(pInput, pOutput, selectColIndex, orderColIndex, 1/* asc */, outputFile); } else if (! orderByDesc.empty()) { int orderColIndex = findNamedColumn(orderByDesc); if (orderColIndex == -1) { std:: cerr << "error: unknown column name '" << orderByDesc << "'" << std:: endl; return 1; } r = do_sorting(pInput, pOutput, selectColIndex, orderColIndex, -1/* desc */, outputFile); } else { r = do_selecting(pInput, pOutput, selectColIndex); } output.close(); input.close(); return r; }