Variant f_mysql_fetch_field(CVarRef result, int field /* = -1 */) { MySQLResult *res = php_mysql_extract_result(result); if (res == NULL) return false; if (field != -1) { if (!res->seekField(field)) return false; } MySQLFieldInfo *info; if (!(info = res->fetchFieldInfo())) return false; Object obj(SystemLib::AllocStdClassObject()); obj->o_set("name", info->name); obj->o_set("table", info->table); obj->o_set("def", info->def); obj->o_set("max_length", (int)info->max_length); obj->o_set("not_null", IS_NOT_NULL(info->flags)? 1 : 0); obj->o_set("primary_key", IS_PRI_KEY(info->flags)? 1 : 0); obj->o_set("multiple_key", info->flags & MULTIPLE_KEY_FLAG? 1 : 0); obj->o_set("unique_key", info->flags & UNIQUE_KEY_FLAG? 1 : 0); obj->o_set("numeric", IS_NUM(info->type)? 1 : 0); obj->o_set("blob", IS_BLOB(info->flags)? 1 : 0); obj->o_set("type", php_mysql_get_field_name(info->type)); obj->o_set("unsigned", info->flags & UNSIGNED_FLAG? 1 : 0); obj->o_set("zerofill", info->flags & ZEROFILL_FLAG? 1 : 0); return obj; }
int ADBColumn::define(uint columnNo, MYSQL_FIELD *mField, const char *newData) { int ret = 0; if (mField) { ADBDebugMsg(7, "ADBColumn::define() clearing currently loaded data for column %d...", columnNo); clear(); // Now, fill in the column name, its type, etc. strncpy(intColumnName, mField->name, ADB_MAXCOLWIDTH - 1); strncpy(intTableName, mField->table, ADB_MAXCOLWIDTH - 1); intDataType = mField->type; intColumnNo = columnNo; isPrimaryKey = IS_PRI_KEY(mField->flags); free(intData); free(intOldData); if (newData) { intData = (char *) calloc(strlen(newData)+16, sizeof(char)); intOldData = (char *) calloc(strlen(newData)+16, sizeof(char)); strcpy(intData, newData); strcpy(intOldData, newData); } else { intData = (char *) calloc(16, sizeof(char)); intOldData = (char *) calloc(16, sizeof(char)); } ret = 1; } return ret; }
void CQueryTable::refresh() { if (isBlocked()) return; reset(); m_cancel = false; if (!query()->isResultNull()) { setBlocked(true); query()->dataSeek(0); uint num_fields = query()->numFields(); ulong num_rows = query()->numRows(); setNumRows(num_rows); setNumCols(num_fields); QPixmap icon; bool columns_ok = (keepColumnWidth() && previous_columns_map.count() == num_fields); if (columns_ok) for (uint i = 0; i < num_fields; i++) columns_ok &= (previous_columns_map[i].label == query()->fields(i).name); if (!columns_ok && keepColumnWidth()) previous_columns_map.clear(); for (uint i = 0; i < num_fields; i++) { if (IS_PRI_KEY(query()->fields(i).flags)) icon = pkIcon; else if (IS_MUL_KEY(query()->fields(i).flags)) icon = mulIcon; else if (IS_UNI_KEY(query()->fields(i).flags)) icon = uniIcon; else icon = nothingIcon; if (columns_ok && previous_columns_map[i].label == query()->fields(i).name) horizontalHeader()->setLabel(i, icon, query()->fields(i).name, previous_columns_map[i].size); else horizontalHeader()->setLabel(i, icon, query()->fields(i).name); } if (hasProcessEvents()) qApp->processEvents(); else updateScrollBars(); ulong j = 0; while (query()->next(!hasProcessEvents())) { if (m_cancel) break; for (uint i = 0; i < num_fields; i++) setText(j, i, query()->row(i)); j++; } setBlocked(false); emit refreshed(); } else if (!previous_columns_map.empty()) previous_columns_map.clear(); }
Variant php_mysql_field_info(const Variant& result, int field, int entry_type) { MySQLResult *res = php_mysql_extract_result(result); if (res == NULL) return false; if (!res->seekField(field)) return false; MySQLFieldInfo *info; if (!(info = res->fetchFieldInfo())) return false; switch (entry_type) { case PHP_MYSQL_FIELD_NAME: return info->name; case PHP_MYSQL_FIELD_TABLE: return info->table; case PHP_MYSQL_FIELD_LEN: return info->length; case PHP_MYSQL_FIELD_TYPE: return php_mysql_get_field_name(info->type); case PHP_MYSQL_FIELD_FLAGS: { char buf[512]; buf[0] = '\0'; unsigned int flags = info->flags; #ifdef IS_NOT_NULL if (IS_NOT_NULL(flags)) { strcat(buf, "not_null "); } #endif #ifdef IS_PRI_KEY if (IS_PRI_KEY(flags)) { strcat(buf, "primary_key "); } #endif #ifdef UNIQUE_KEY_FLAG if (flags & UNIQUE_KEY_FLAG) { strcat(buf, "unique_key "); } #endif #ifdef MULTIPLE_KEY_FLAG if (flags & MULTIPLE_KEY_FLAG) { strcat(buf, "multiple_key "); } #endif #ifdef IS_BLOB if (IS_BLOB(flags)) { strcat(buf, "blob "); } #endif #ifdef UNSIGNED_FLAG if (flags & UNSIGNED_FLAG) { strcat(buf, "unsigned "); } #endif #ifdef ZEROFILL_FLAG if (flags & ZEROFILL_FLAG) { strcat(buf, "zerofill "); } #endif #ifdef BINARY_FLAG if (flags & BINARY_FLAG) { strcat(buf, "binary "); } #endif #ifdef ENUM_FLAG if (flags & ENUM_FLAG) { strcat(buf, "enum "); } #endif #ifdef SET_FLAG if (flags & SET_FLAG) { strcat(buf, "set "); } #endif #ifdef AUTO_INCREMENT_FLAG if (flags & AUTO_INCREMENT_FLAG) { strcat(buf, "auto_increment "); } #endif #ifdef TIMESTAMP_FLAG if (flags & TIMESTAMP_FLAG) { strcat(buf, "timestamp "); } #endif int len = strlen(buf); /* remove trailing space, if present */ if (len && buf[len-1] == ' ') { buf[len-1] = 0; len--; } return String(buf, len, CopyString); } default: break; } return false; }
int main(int argc, char* argv[]) { char sPGhost[26], sPGport[26], sPGdb[26], sPGuser[26], sPGpass[26]; printf("Postgres connection settings\n Host>"); scanf("%s", sPGhost); printf(" Port>"); scanf("%s", sPGport); printf(" Base>"); scanf("%s", sPGdb); printf(" User>"); scanf("%s", sPGuser); printf(" Pass>"); scanf("%s", sPGpass); /////////////////////////////// ///////PGSQL Connect/////////// /////////////////////////////// PGconn* mPGconn = NULL; mPGconn = PQsetdbLogin(sPGhost, sPGport, NULL, NULL, sPGdb, sPGuser, sPGpass); if (PQstatus(mPGconn) != CONNECTION_OK) { printf("Could not connect to Postgre database at [%s]: \n %s\n", sPGhost, PQerrorMessage(mPGconn)); PQfinish(mPGconn); return 1; } else { printf("Connected to Postgre database at [%s]\n", sPGhost); printf(" PostgreSQL server ver: [%d]\n\n", PQserverVersion(mPGconn)); } /// Set dummy notice processor PQsetNoticeProcessor(mPGconn, pg_notice, mPGconn); /////////////////////////////// ///////MySQL Connect/////////// /////////////////////////////// MYSQL* mysqlInit; mysqlInit = mysql_init(NULL); if (!mysqlInit) { printf("Could not initialize Mysql connection\n"); return 1; } char sMYhost[26], sMYdb[26], sMYuser[26], sMYpass[26]; int iMYport; printf("Mysql connection settings \n Host>"); scanf("%s", sMYhost); printf(" Port>"); scanf("%d", &iMYport); printf(" Base>"); scanf("%s", sMYdb); printf(" User>"); scanf("%s", sMYuser); printf(" Pass>"); scanf("%s", sMYpass); mysql_options(mysqlInit, MYSQL_SET_CHARSET_NAME, "utf8"); MYSQL* mMysql; mMysql = mysql_real_connect(mysqlInit, sMYhost, sMYuser, sMYpass, sMYdb, iMYport, NULL, 0); if (mMysql) { printf("Connected to MySQL database at [%s] \n", sMYhost); printf(" MySQL client library: [%s] \n", mysql_get_client_info()); printf(" MySQL server ver: [%s] \n\n", mysql_get_server_info(mMysql)); } else { printf("Could not connect to MySQL database at [%s]:\n %s\n", sMYhost , mysql_error(mysqlInit)); mysql_close(mysqlInit); return 1; } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// MYSQL_RES* result = NULL; MYSQL_ROW row; MYSQL_FIELD* fields = NULL; uint64 rowCount = 0; uint32 fieldCount = 0; result = mysql_list_tables(mMysql , NULL); rowCount = mysql_num_rows(result); /***********************/ /* get list of tables */ /***********************/ T_TableList mTableList; mTableList.reserve((size_t)rowCount); while ((row = mysql_fetch_row(result)) != NULL) { for (uint32 i = 0; i < mysql_num_fields(result); i++) { mTableList.push_back(row[i]); } } mysql_free_result(result); /****************************************/ /* convert filed type and default type */ /****************************************/ T_Table m_Table; TDataBase m_DataBase_Map; m_DataBase_Map.clear(); for (uint32 j = 0; j < mTableList.size(); ++j) { result = mysql_list_fields(mMysql, mTableList[j].c_str(), NULL); fieldCount = mysql_num_fields(result); fields = mysql_fetch_fields(result); for (uint32 i = 0; i < fieldCount; ++i) { sField mfield; mfield.name = fields[i].name; if (!fields[i].def) { mfield.def = "NULL"; } else if (!strcmp(fields[i].def, "0000-00-00 00:00:00")) { /// Convert MySQL Default timestamp to PGSQL Default timestamp mfield.def.append("'1970-01-01 00:00:00'"); } else { /// Append ' mfield.def.append("'"); mfield.def.append(fields[i].def);; mfield.def.append("'"); } mfield.type = ConvertNativeType(fields[i].type, fields[i].length); mfield.flags = fields[i].flags; m_Table.push_back(mfield); } m_DataBase_Map[mTableList[j]] = m_Table; m_Table.clear(); mysql_free_result(result); } /******************************************/ /* Conversion of the layout of the tables */ /******************************************/ uint32 count = 0; TDataBase::const_iterator citr; for (citr = m_DataBase_Map.begin(); citr != m_DataBase_Map.end(); ++citr) { ostringstream sql_str; sql_str << "DROP TABLE IF EXISTS " << (*citr).first.c_str() << ";\n"; sql_str << "CREATE TABLE " << (*citr).first.c_str() << "(\n"; T_Table::const_iterator v_iter; ostringstream prim_key_str; ostringstream index_str; for (v_iter = (*citr).second.begin(); v_iter != (*citr).second.end(); ++v_iter) { sql_str << " " << (*v_iter).name; if (((*v_iter).flags & AUTO_INCREMENT_FLAG) != 0) { /// AUTO_INCREMENT fields not have "default" data sql_str << " bigserial"; } else { sql_str << " " << (*v_iter).type; sql_str << " default " << (*v_iter).def; } /// IF column have PRIMARY KEY flag then use column in PRIMARY KEY if (IS_PRI_KEY((*v_iter).flags) != 0) { if (prim_key_str.str().size()) prim_key_str << ", "; else { prim_key_str << "ALTER TABLE "; prim_key_str << (*citr).first.c_str(); prim_key_str << " ADD CONSTRAINT pk_"; prim_key_str << (*citr).first.c_str(); prim_key_str << "_"; prim_key_str << (*v_iter).name; prim_key_str << " PRIMARY KEY ("; } prim_key_str << (*v_iter).name; } else if (((*v_iter).flags & MULTIPLE_KEY_FLAG) != 0) { /// IF column have INDEX flag then create INDEX index_str << "CREATE INDEX idx_"; index_str << (*citr).first.c_str(); index_str << "_"; index_str << (*v_iter).name; index_str << " ON "; index_str << (*citr).first.c_str(); index_str << " USING btree ("; index_str << (*v_iter).name; index_str << ");\n"; } else if (((*v_iter).flags & UNIQUE_KEY_FLAG) != 0) { /// IF column have UNIQUE INDEX flag then create INDEX index_str << "CREATE UNIQUE INDEX uidx_"; index_str << (*citr).first.c_str(); index_str << "_"; index_str << (*v_iter).name; index_str << " ON "; index_str << (*citr).first.c_str(); index_str << " USING btree ("; index_str << (*v_iter).name; index_str << ");\n"; } /// don't output "," for last column if (v_iter + 1 != (*citr).second.end()) sql_str << ",\n"; else sql_str << "\n"; } sql_str << ")\n"; /// Out Table structure PG_Exec_str(sql_str.str(), mPGconn); /// out PRIMARY KEY if (prim_key_str.str().size()) { prim_key_str << ")"; PG_Exec_str(prim_key_str.str(), mPGconn); } /// out INDEX's if (index_str.str().size()) PG_Exec_str(index_str.str(), mPGconn); ++count; printf("Convert [%d] tables...\r", count); } printf("Completed the conversion of [%d] tables!\n", count); /****************/ /* Copying data */ /****************/ count = 0; for (uint32 j = 0; j < mTableList.size(); ++j) { ostringstream sql_str; sql_str << "SELECT * FROM "; sql_str << mTableList[j].c_str(); if (mysql_query(mysqlInit, sql_str.str().c_str())) continue; if (!(result = mysql_store_result(mysqlInit))) continue; while ((row = mysql_fetch_row(result)) != NULL) { ostringstream insert_str; insert_str << "INSERT INTO "; insert_str << mTableList[j].c_str(); insert_str << " VALUES ("; fieldCount = mysql_num_fields(result); fields = mysql_fetch_fields(result); for (uint32 i = 0 ; i < fieldCount ; ++i) { if (!row[i]) insert_str << "NULL"; else { if (IsNeeedEscapeString(fields[i].type)) { string field_str = row[i]; PG_Escape_Str(field_str); insert_str << "E'"; insert_str << field_str.c_str(); insert_str << "'"; } else if (!strcmp(row[i], "0000-00-00 00:00:00")) { /// Convert MySQL timestamp to PGSQL timestamp insert_str << "'1970-01-01 00:00:00'"; } else { insert_str << "'"; insert_str << row[i]; insert_str << "'"; } } /// don't output "," for last column if (i + 1 != fieldCount) insert_str << ","; else insert_str << ")\n"; } PG_Exec_str(insert_str.str(), mPGconn); } mysql_free_result(result); ++count; printf("Copied data from [%d] tables...\r", count); } printf("Finished copying the data from [%d] tables!\n", count); mTableList.clear(); m_DataBase_Map.clear(); /// Close connections mysql_close(mMysql); PQfinish(mPGconn); printf("end\n"); return 0; }
int mysql_dumper_dump(struct mysql_login_info *mysql_login_info, const char *outputdir, const char *dbname, const char *tablename, const char *query, size_t query_len, struct mysql_dumper_type *types) { MYSQL mysql; MYSQL_STMT *stmt = NULL; mysql_init(&mysql); my_bool b_flag = 1; if (0 != mysql_options(&mysql, MYSQL_OPT_RECONNECT, (const char *)&b_flag)) return report_error(&mysql); if (NULL == mysql_real_connect(&mysql, mysql_login_info->host, mysql_login_info->user, mysql_login_info->pass, mysql_login_info->db, mysql_login_info->port, NULL, CLIENT_COMPRESS)) return report_error(&mysql); b_flag = 0; if (0 != mysql_options(&mysql, MYSQL_REPORT_DATA_TRUNCATION, (const char *)&b_flag)) return report_error(&mysql); stmt = mysql_stmt_init(&mysql); if (!stmt) return report_error(&mysql); if (0 != mysql_stmt_prepare(stmt, query, query_len)) return report_stmt_error(&mysql, stmt); MYSQL_RES *rs = mysql_stmt_result_metadata(stmt); if (!rs) return report_stmt_error(&mysql, stmt); unsigned int n = mysql_num_fields(rs); MYSQL_FIELD *fields = mysql_fetch_fields(rs); int field_types[n]; MYSQL_BIND bind[n]; my_bool is_null[n]; unsigned long length[n]; my_bool error[n]; memset(bind, 0, sizeof(MYSQL_BIND) * n); int null_terminate_str[n]; memset(null_terminate_str, 0, sizeof(int) * n); struct file_writer ffields[n]; struct file_writer vfields[2][n]; struct vmbuf buf = VMBUF_INITIALIZER; vmbuf_init(&buf, 4096); vmbuf_sprintf(&buf, "%s/%s/%s/schema.txt", outputdir, dbname, tablename); mkdir_for_file_recursive(vmbuf_data(&buf)); int fdschema = creat(vmbuf_data(&buf), 0644); struct vmfile ds_txt = VMFILE_INITIALIZER; vmbuf_reset(&buf); vmbuf_sprintf(&buf, "%s/%s/%s/ds.txt", outputdir, dbname, tablename); if (0 > vmfile_init(&ds_txt, vmbuf_data(&buf), 4096)) return LOGGER_ERROR("failed to create: %s", vmbuf_data(&buf)), vmbuf_free(&buf), -1; vmfile_sprintf(&ds_txt, "DS_LOADER_BEGIN()\n"); vmfile_sprintf(&ds_txt, "/*\n * DB: %s\n */\n", dbname); vmfile_sprintf(&ds_txt, "#undef DB_NAME\n#define DB_NAME %s\n", dbname); ssize_t len = 80 - strlen(tablename); if (len < 0) len = 4; char header[len]; memset(header, '=', len); vmfile_sprintf(&ds_txt, "/* %.*s[ %s ]%.*s */\n", (int)len / 2, header, tablename, (int)(len - (len / 2)), header); vmfile_sprintf(&ds_txt, "# undef TABLE_NAME\n# define TABLE_NAME %s\n", tablename); /* * initialize output files */ unsigned int i; for (i = 0; i < n; ++i) { file_writer_make(&ffields[i]); file_writer_make(&vfields[0][i]); file_writer_make(&vfields[1][i]); } struct hashtable ht_types = HASHTABLE_INITIALIZER; hashtable_init(&ht_types, 32); if (NULL != types) { struct mysql_dumper_type *t = types; for (; t->name; ++t) { /* storing ptr here which points to static str */ hashtable_insert(&ht_types, t->name, strlen(t->name), t, sizeof(struct mysql_dumper_type)); } } /* * parse meta data and construct bind array */ int err = 0; for (i = 0; i < n; ++i) { field_types[i] = fields[i].type; bind[i].is_unsigned = IS_UNSIGNED(fields[i].flags); int64_t ds_type = -1; const char *ds_type_str = "VAR"; /* * handle overrides */ while (NULL != types) { uint32_t ofs = hashtable_lookup(&ht_types, fields[i].name, strlen(fields[i].name)); if (!ofs) break; struct mysql_dumper_type *type = (struct mysql_dumper_type *)hashtable_get_val(&ht_types, ofs); null_terminate_str[i] = MYSQL_DUMPER_CSTR & type->flags; if (type->mysql_type) field_types[i] = type->mysql_type; bind[i].is_unsigned = (type->flags & MYSQL_DUMPER_UNSIGNED) > 0 ? 1 : 0; break; } vmbuf_reset(&buf); vmbuf_sprintf(&buf, "%s/%s/%s/%s", outputdir, dbname, tablename, fields[i].name); mkdir_for_file_recursive(vmbuf_data(&buf)); if (is_var_length_field(field_types[i])) { size_t ofs = vmbuf_wlocpos(&buf); vmbuf_sprintf(&buf, ".ofs"); if (0 > (err = file_writer_init(&vfields[0][i], vmbuf_data(&buf)))) break; vmbuf_wlocset(&buf, ofs); vmbuf_sprintf(&buf, ".dat"); if (0 > (err = file_writer_init(&vfields[1][i], vmbuf_data(&buf)))) break; } else { ds_type = get_ds_type(field_types[i], bind[i].is_unsigned); const char *s = get_ds_type_str(ds_type); if (*s) ds_type_str = s; if (0 > (err = file_writer_init(&ffields[i], vmbuf_data(&buf))) || 0 > (err = file_writer_write(&ffields[i], &ds_type, sizeof(ds_type)))) break;; } len = ribs_mysql_get_storage_size(field_types[i], fields[i].length); if (fdschema > 0) dprintf(fdschema, "%03d name = %s, size=%zu, length=%lu, type=%s (%s), is_prikey=%d, ds_type=%s\n", i, fields[i].name, len, fields[i].length, ribs_mysql_get_type_name(field_types[i]), bind[i].is_unsigned ? "unsigned" : "signed", IS_PRI_KEY(fields[i].flags), ds_type_str); if (is_var_length_field(field_types[i])) { vmfile_sprintf(&ds_txt, " DS_VAR_FIELD_LOADER(%s)\n", fields[i].name); } else { vmfile_sprintf(&ds_txt, " DS_FIELD_LOADER(%s, %s)\n", ds_type_str, fields[i].name); } bind[i].buffer_type = field_types[i]; bind[i].buffer_length = len; bind[i].buffer = malloc(len); bind[i].is_null = &is_null[i]; bind[i].length = &length[i]; bind[i].error = &error[i]; } hashtable_free(&ht_types); mysql_free_result(rs); close(fdschema); //vmfile_sprintf(&ds_txt, "/*\n * TABLE END: %s\n */\n", tablename); vmfile_sprintf(&ds_txt, "DS_LOADER_END()\n"); vmfile_close(&ds_txt); /* * execute & bind */ if (0 != err || 0 != mysql_stmt_execute(stmt) || 0 != mysql_stmt_bind_result(stmt, bind)) { err = -1; report_stmt_error(&mysql, stmt); goto dumper_close_writer; } char zeros[4096]; memset(zeros, 0, sizeof(zeros)); int mysql_err = 0; size_t count = 0, num_rows_errors = 0; /* * write all rows to output files */ while (0 == (mysql_err = mysql_stmt_fetch(stmt))) { int b = 0; for (i = 0; i < n && !b; ++i) b = b || error[i]; if (b) { ++num_rows_errors; continue; } for (i = 0; i < n; ++i) { if (is_var_length_field(field_types[i])) { size_t ofs = file_writer_wlocpos(&vfields[1][i]); if (0 > (err = file_writer_write(&vfields[0][i], &ofs, sizeof(ofs))) || 0 > (err = file_writer_write(&vfields[1][i], is_null[i] ? NULL : bind[i].buffer, is_null[i] ? 0 : length[i]))) goto dumper_error; if (null_terminate_str[i]) { const char c = '\0'; if (0 > (err = file_writer_write(&vfields[1][i], &c, sizeof(c)))) goto dumper_error; } } else { if (0 > (err = file_writer_write(&ffields[i], is_null[i] ? zeros : bind[i].buffer, bind[i].buffer_length))) goto dumper_error; } } ++count; } /* no dumper errors */ goto dumper_ok; dumper_error: LOGGER_ERROR("failed to write data, aborting"); dumper_ok: /* we are done with mysql, close it */ mysql_stmt_close(stmt); mysql_close(&mysql); LOGGER_INFO("%s: %zu records, %zu skipped", tablename, count, num_rows_errors); /* check for mysql errors */ if (mysql_err != MYSQL_NO_DATA) { LOGGER_ERROR("mysql_stmt_fetch returned an error (code=%d)\n", mysql_err); err = -1; } dumper_close_writer: /* * finalize & free memory */ for (i = 0; i < n; ++i) { if (is_var_length_field(field_types[i])) { size_t ofs = file_writer_wlocpos(&vfields[1][i]); if (0 > (err = file_writer_write(&vfields[0][i], &ofs, sizeof(ofs)))) LOGGER_ERROR("failed to write offset"); file_writer_close(&vfields[0][i]); file_writer_close(&vfields[1][i]); } else { file_writer_close(&ffields[i]); } free(bind[i].buffer); } vmbuf_free(&buf); return err; }
OGRFeatureDefn *OGRMySQLResultLayer::ReadResultDefinition() { /* -------------------------------------------------------------------- */ /* Parse the returned table information. */ /* -------------------------------------------------------------------- */ OGRFeatureDefn *poDefn = new OGRFeatureDefn( "sql_statement" ); SetDescription( poDefn->GetName() ); poDefn->Reference(); mysql_field_seek( hResultSet, 0 ); for( int iRawField = 0; iRawField < (int) mysql_num_fields(hResultSet); iRawField++ ) { MYSQL_FIELD *psMSField = mysql_fetch_field( hResultSet ); OGRFieldDefn oField( psMSField->name, OFTString); switch( psMSField->type ) { case FIELD_TYPE_TINY: case FIELD_TYPE_SHORT: case FIELD_TYPE_LONG: case FIELD_TYPE_INT24: case FIELD_TYPE_LONGLONG: { oField.SetType( OFTInteger ); const int width = (int)psMSField->length; oField.SetWidth(width); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_DECIMAL: #ifdef FIELD_TYPE_NEWDECIMAL case FIELD_TYPE_NEWDECIMAL: #endif { oField.SetType( OFTReal ); // a bunch of hackery to munge the widths that MySQL gives // us into corresponding widths and precisions for OGR const int precision = (int)psMSField->decimals; int width = (int)psMSField->length; if (!precision) width = width - 1; width = width - precision; oField.SetWidth(width); oField.SetPrecision(precision); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_FLOAT: case FIELD_TYPE_DOUBLE: /* MYSQL_FIELD is always reporting ->length = 22 and ->decimals = 31 for double type regardless of the data it returned. In an example, the data it returned had only 5 or 6 decimal places which were exactly as entered into the database but reported the decimals as 31. */ /* Assuming that a length of 22 means no particular width and 31 decimals means no particular precision. */ { const int width = (int)psMSField->length; const int precision = (int)psMSField->decimals; oField.SetType( OFTReal ); if( width != 22 ) oField.SetWidth(width); if( precision != 31 ) oField.SetPrecision(precision); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_DATE: { oField.SetType( OFTDate ); oField.SetWidth(0); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_TIME: { oField.SetType( OFTTime ); oField.SetWidth(0); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_TIMESTAMP: case FIELD_TYPE_DATETIME: { oField.SetType( OFTDateTime ); oField.SetWidth(0); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_YEAR: case FIELD_TYPE_STRING: case FIELD_TYPE_VAR_STRING: { oField.SetType( OFTString ); oField.SetWidth((int)psMSField->length); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_TINY_BLOB: case FIELD_TYPE_MEDIUM_BLOB: case FIELD_TYPE_LONG_BLOB: case FIELD_TYPE_BLOB: { if( psMSField->charsetnr == 63 ) oField.SetType( OFTBinary ); else oField.SetType( OFTString ); oField.SetWidth((int)psMSField->max_length); poDefn->AddFieldDefn( &oField ); break; } case FIELD_TYPE_GEOMETRY: { if (pszGeomColumn == nullptr) { pszGeomColumnTable = CPLStrdup( psMSField->table); pszGeomColumn = CPLStrdup( psMSField->name); } break; } default: // any other field we ignore. break; } // assume a FID name first, and if it isn't there // take a field that is not null, a primary key, // and is an integer-like field if( EQUAL(psMSField->name,"ogc_fid") ) { bHasFid = TRUE; pszFIDColumn = CPLStrdup(oField.GetNameRef()); continue; } else if (IS_NOT_NULL(psMSField->flags) && IS_PRI_KEY(psMSField->flags) && ( psMSField->type == FIELD_TYPE_TINY || psMSField->type == FIELD_TYPE_SHORT || psMSField->type == FIELD_TYPE_LONG || psMSField->type == FIELD_TYPE_INT24 || psMSField->type == FIELD_TYPE_LONGLONG ) ) { bHasFid = TRUE; pszFIDColumn = CPLStrdup(oField.GetNameRef()); continue; } } poDefn->SetGeomType( wkbNone ); if (pszGeomColumn) { char* pszType=nullptr; CPLString osCommand; char **papszRow; // set to unknown first poDefn->SetGeomType( wkbUnknown ); poDefn->GetGeomFieldDefn(0)->SetName( pszGeomColumn ); osCommand.Printf( "SELECT type FROM geometry_columns WHERE f_table_name='%s'", pszGeomColumnTable ); if( hResultSet != nullptr ) mysql_free_result( hResultSet ); hResultSet = nullptr; if( !mysql_query( poDS->GetConn(), osCommand ) ) hResultSet = mysql_store_result( poDS->GetConn() ); papszRow = nullptr; if( hResultSet != nullptr ) papszRow = mysql_fetch_row( hResultSet ); if( papszRow != nullptr && papszRow[0] != nullptr ) { pszType = papszRow[0]; OGRwkbGeometryType l_nGeomType = OGRFromOGCGeomType(pszType); poDefn->SetGeomType( l_nGeomType ); } nSRSId = FetchSRSId(); } return poDefn; }
/* is_pri_key? */ static VALUE field_is_pri_key(VALUE obj) { return IS_PRI_KEY(NUM2INT(rb_iv_get(obj, "flags"))) ? Qtrue : Qfalse; }