Java.sql.ResultSet से कॉलम नामों को पुनः प्राप्त करें

233

साथ java.sql.ResultSetवहाँ एक रास्ता एक के रूप में एक स्तंभ के नाम पाने के लिए है Stringस्तंभ के सूचकांक का उपयोग करके? मैं एपीआई डॉक्टर के माध्यम से एक नज़र था, लेकिन मैं कुछ भी नहीं मिल सकता है।

java jdbc

— BalusC
स्रोत

372

आप यह जानकारी ResultSetमेटाडेटा से प्राप्त कर सकते हैं । ResultSetMetaData देखें

जैसे

 ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2");
 ResultSetMetaData rsmd = rs.getMetaData();
 String name = rsmd.getColumnName(1);

और आप वहां से कॉलम नाम प्राप्त कर सकते हैं। यदि तुम करो

select x as y from table

फिर rsmd.getColumnLabel()आपको पुनर्प्राप्त लेबल नाम भी मिलेगा।

— ब्रायन एग्न्यू
स्रोत

22

यह भी देखें rsmd.getColumnLabelकि क्या आप लेबल के साथ कॉलम पुनः प्राप्त करते हैं (उदाहरण के लिएSELECT columnName AS ColumnLabel

— T30

15

आप मुझे देखकर आश्चर्यचकित हो सकते हैं क्योंकि कॉलम की गिनती 1 से शुरू हो रही है। आप कॉलम नामों के माध्यम से पुनरावृति कर सकते हैंfor (int i = 1; i <= rsmd.getColumnCount(); i++) String name = rsmd.getColumnName(i);

— Alphaaa

है getColumnName()मूल स्तंभ नाम वापसी करता है, तो उपयोग नहीं कर ASनामकरण उर्फ?

— मेसाउंड

2

@membersound हाँ, जैसा कि इसके जावदोक में प्रलेखित है : "यदि एक एसक्यूएल ASनिर्दिष्ट नहीं है, तो लौटाया गया मान getColumnLabelवैसा ही होगा, जैसा कि getColumnNameविधि द्वारा दिया गया मान है ।" । लगभग सभी मामलों में आपको getColumnLabelइसके बजाय उपयोग करना चाहिए getColumnName।

— मार्क रोटेवेल

1

यदि तालिका खाली है तो यह विफल हो जाएगा।

— बजे

140

उपरोक्त उत्तरों के अलावा, यदि आप एक गतिशील क्वेरी के साथ काम कर रहे हैं और आप कॉलम नाम चाहते हैं, लेकिन यह नहीं जानते हैं कि कितने कॉलम हैं, तो आप ResultSetMetaData ऑब्जेक्ट का उपयोग करके पहले कॉलम की संख्या प्राप्त कर सकते हैं और फिर उनके माध्यम से साइकिल चला सकते हैं। ।

ब्रायन के कोड में संशोधन:

ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2");
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();

// The column count starts from 1
for (int i = 1; i <= columnCount; i++ ) {
  String name = rsmd.getColumnName(i);
  // Do stuff with name
}

— Cyntech
स्रोत

क्या यह सही नहीं है? for (int i = 1; i <= columnCount + 1; i ++) {...}

— मार्टिन

3

@Martin नहीं, क्योंकि वह स्तंभ n + 1 प्राप्त करने का प्रयास करेगा जो मौजूद नहीं है। यदि आप पूरी तरह से संक्षिप्त होना चाहते हैं, तो यह होगा i <= columnCount।

— Cyntech

21

आप इसके लिए ResultSetMetaData ( http://java.sun.com/javase/6/docs/api/java/sql/ResultSetMetaData.html ) ऑब्जेक्ट का उपयोग कर सकते हैं :

ResultSet rs = stmt.executeQuery("SELECT * FROM table");
ResultSetMetaData rsmd = rs.getMetaData();
String firstColumnName = rsmd.getColumnName(1);

— साइमन
स्रोत

1

thanx यह मेरी मदद की ... मैं इसे के रूप में इस्तेमाल किया: resultSet.getString (resultSet.findColumn ("fullname"))

— C

1. रिकॉर्ड किए गए रिकॉर्ड को सीमित करें 1. अन्यथा यदि तालिका बहुत बड़ी है, तो अनावश्यक ओवरहेड। टेराडाटबेस के लिए उदाहरण: क्वेरी का उपयोग करें "सेलेक्ट करें * टेबल

— सैम्पल

11

यह प्रश्न पुराना है और इसलिए पिछले उत्तर सही हैं। लेकिन जब मैं इस विषय को ढूंढ रहा था तो मुझे इस समाधान की तरह कुछ था। उम्मीद है कि यह किसी की मदद करता है।

// Loading required libraries    
import java.util.*;
import java.sql.*;

public class MySQLExample {
  public void run(String sql) {
    // JDBC driver name and database URL
    String JDBC_DRIVER = "com.mysql.jdbc.Driver";
    String DB_URL = "jdbc:mysql://localhost/demo";

    // Database credentials
    String USER = "someuser"; // Fake of course.
    String PASS = "somepass"; // This too!

    Statement stmt = null;
    ResultSet rs = null;
    Connection conn = null;
    Vector<String> columnNames = new Vector<String>();

    try {
      // Register JDBC driver
      Class.forName(JDBC_DRIVER);

      // Open a connection
      conn = DriverManager.getConnection(DB_URL, USER, PASS);

      // Execute SQL query
      stmt = conn.createStatement();
      rs = stmt.executeQuery(sql);
      if (rs != null) {
        ResultSetMetaData columns = rs.getMetaData();
        int i = 0;
        while (i < columns.getColumnCount()) {
          i++;
          System.out.print(columns.getColumnName(i) + "\t");
          columnNames.add(columns.getColumnName(i));
        }
        System.out.print("\n");

        while (rs.next()) {
          for (i = 0; i < columnNames.size(); i++) {
            System.out.print(rs.getString(columnNames.get(i))
                + "\t");

          }
          System.out.print("\n");
        }

      }
    } catch (Exception e) {
      System.out.println("Exception: " + e.toString());
    }

    finally {
      try {
        if (rs != null) {
          rs.close();
        }
        if (stmt != null) {
          stmt.close();
        }
        if (conn != null) {
          conn.close();
        }
      } catch (Exception mysqlEx) {
        System.out.println(mysqlEx.toString());
      }

    }
  }
}

— रोनाल्ड वीडर
स्रोत

5

SQLite 3

GetMetaData () का उपयोग करना;

DatabaseMetaData md = conn.getMetaData();
ResultSet rset = md.getColumns(null, null, "your_table_name", null);

System.out.println("your_table_name");
while (rset.next())
{
    System.out.println("\t" + rset.getString(4));
}

EDIT: यह PostgreSQL के साथ भी काम करता है

— Sedrick
स्रोत

इसे टेराडेटा डेटाबेस पर आज़माया और त्रुटि मिली "[टेरडेटा डेटाबेस] [TeraJDBC 16.20.00.02] [त्रुटि 9719] [SQLState HY000] QVCI सुविधा अक्षम है।"

— josepainumkal

2

import java.sql.*;

public class JdbcGetColumnNames {

    public static void main(String args[]) {
        Connection con = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            con = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/komal", "root", "root");

            st = con.createStatement();

            String sql = "select * from person";
            rs = st.executeQuery(sql);
            ResultSetMetaData metaData = rs.getMetaData();

            int rowCount = metaData.getColumnCount();

            System.out.println("Table Name : " + metaData.getTableName(2));
            System.out.println("Field  \tDataType");

            for (int i = 0; i < rowCount; i++) {
                System.out.print(metaData.getColumnName(i + 1) + "  \t");
                System.out.println(metaData.getColumnTypeName(i + 1));
            }
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

तालिका का नाम: व्यक्ति फ़ील्ड डेटा टाइप आईडी VARCHAR cname VARCHAR dob DATE

— दीप राठौड़
स्रोत

1

जब आपको कॉलम नामों की आवश्यकता होती है, लेकिन प्रविष्टियों को हथियाना नहीं चाहते हैं:

PreparedStatement stmt = connection.prepareStatement("SHOW COLUMNS FROM `yourTable`");

ResultSet set = stmt.executeQuery();

//store all of the columns names
List<String> names = new ArrayList<>();
while (set.next()) { names.add(set.getString("Field")); }

नोट: केवल MySQL के साथ काम करता है

— हंटर एस
स्रोत

1

केवल यह मेरे लिए काम किया !! इसके लिए नीचे आना पड़ा। निश्चित नहीं है कि क्यों getColumnName (i) और getColumnLabel (i), मुझे अप्रत्याशित अजीब डेटा पुनर्प्राप्त करता है। बहुत धन्यवाद!

— विपिन नेगी

खुशी है कि यह आपकी मदद की!

— हंटर एस

1

while (rs.next()) {
   for (int j = 1; j < columncount; j++) {
       System.out.println( rsd.getColumnName(j) + "::" + rs.getString(j));      
   }
}

— जगदीश चेन्ना
स्रोत

6

कृपया, क्या आप अधिक विस्तृत विवरण के साथ अपने उत्तर का विस्तार कर सकते हैं? यह समझने के लिए बहुत उपयोगी होगा। धन्यवाद!

— वेजुन्चिक

1

SQL क्वेरी जो डेटाबेस क्वेरी से डेटा पढ़ते हैं, परिणाम सेट में डेटा वापस करते हैं। SELECT स्टेटमेंट एक डेटाबेस से पंक्तियों को चुनने और उन्हें परिणाम सेट में देखने का मानक तरीका है। **java.sql.ResultSet**इंटरफ़ेस एक डेटाबेस क्वेरी के परिणाम सेट का प्रतिनिधित्व करता है।

तरीके प्राप्त करें: वर्तमान पंक्ति के कॉलम में डेटा को कर्सर द्वारा इंगित किए जाने के लिए देखने के लिए उपयोग किया जाता है।

का उपयोग करते हुए MetaData of a result set to fetch the exact column count

ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2");
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
boolean b = rsmd.isSearchable(1);

http://docs.oracle.com/javase/7/docs/api/java/sql/ResultSetMetaData.html

और इसे और अधिक डेटा मॉडल तालिका में बांधने के लिए

public static void main(String[] args) {
    Connection conn = null;
    Statement stmt = null;
    try {
        //STEP 2: Register JDBC driver
        Class.forName("com.mysql.jdbc.Driver");

        //STEP 3: Open a connection
        System.out.println("Connecting to a selected database...");
        conn = DriverManager.getConnection(DB_URL, USER, PASS);
        System.out.println("Connected database successfully...");

        //STEP 4: Execute a query
        System.out.println("Creating statement...");
        stmt = conn.createStatement();

        String sql = "SELECT id, first, last, age FROM Registration";
        ResultSet rs = stmt.executeQuery(sql);
        //STEP 5: Extract data from result set
        while(rs.next()){
            //Retrieve by column name
            int id  = rs.getInt("id");
            int age = rs.getInt("age");
            String first = rs.getString("first");
            String last = rs.getString("last");

            //Display values
            System.out.print("ID: " + id);
            System.out.print(", Age: " + age);
            System.out.print(", First: " + first);
            System.out.println(", Last: " + last);
        }
        rs.close();
    } catch(SQLException se) {
        //Handle errors for JDBC
        se.printStackTrace();
    } catch(Exception e) {
        //Handle errors for Class.forName
        e.printStackTrace();
    } finally {
        //finally block used to close resources
        try {
            if(stmt!=null)
                conn.close();
        } catch(SQLException se) {
        } // do nothing
        try {
            if(conn!=null)
                conn.close();
        } catch(SQLException se) {
            se.printStackTrace();
        } //end finally try
    }//end try
    System.out.println("Goodbye!");
}//end main
//end JDBCExample

यहाँ बहुत अच्छा ट्यूटोरियल: http://www.tutorialspoint.com/jdbc/

ResultSetMetaData meta = resultset.getMetaData();  // for a valid resultset object after executing query

Integer columncount = meta.getColumnCount();

int count = 1 ; // start counting from 1 always

String[] columnNames = null;

while(columncount <=count) {
    columnNames [i] = meta.getColumnName(i);
}

System.out.println (columnNames.size() ); //see the list and bind it to TableModel object. the to your jtbale.setModel(your_table_model);

— डैनियल एडेन्यू
स्रोत

0

@Cyntech सही है।

अपनी तालिका खाली करें और आपको अभी भी तालिका स्तंभ नाम प्राप्त करने की आवश्यकता है आप अपने कॉलम को वेक्टर के रूप में प्राप्त कर सकते हैं, निम्नलिखित देखें:

ResultSet rs = stmt.executeQuery("SELECT a, b, c FROM TABLE2");
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();

Vector<Vector<String>>tableVector = new Vector<Vector<String>>(); 
boolean isTableEmpty = true;
int col = 0;

 while(rs.next())
    {
      isTableEmpty = false;  //set to false since rs.next has data: this means the table is not empty
       if(col != columnCount)
          {
            for(int x = 1;x <= columnCount;x++){
                 Vector<String> tFields = new Vector<String>(); 
                 tFields.add(rsmd.getColumnName(x).toString());
                 tableVector.add(tFields);
             }
            col = columnCount;
          }
     } 


      //if table is empty then get column names only
  if(isTableEmpty){  
      for(int x=1;x<=colCount;x++){
           Vector<String> tFields = new Vector<String>(); 
           tFields.add(rsmd.getColumnName(x).toString());
           tableVector.add(tFields);
        }
      }

 rs.close();
 stmt.close();

 return tableVector;

— 21stking
स्रोत

0

ResultSet rsTst = hiSession.connection().prepareStatement(queryStr).executeQuery(); 
ResultSetMetaData meta = rsTst.getMetaData();
int columnCount = meta.getColumnCount();
// The column count starts from 1

String nameValuePair = "";
while (rsTst.next()) {
    for (int i = 1; i < columnCount + 1; i++ ) {
        String name = meta.getColumnName(i);
        // Do stuff with name

        String value = rsTst.getString(i); //.getObject(1);
        nameValuePair = nameValuePair + name + "=" +value + ",";
        //nameValuePair = nameValuePair + ", ";
    }
    nameValuePair = nameValuePair+"||" + "\t";
}

— रबी
स्रोत

0

यदि आप स्प्रिंग jdbctemplate का उपयोग करना चाहते हैं और कनेक्शन कर्मचारियों के साथ व्यवहार नहीं करना चाहते हैं, तो आप निम्नलिखित का उपयोग कर सकते हैं:

jdbcTemplate.query("select * from books", new RowCallbackHandler() {
        public void processRow(ResultSet resultSet) throws SQLException {
            ResultSetMetaData rsmd = resultSet.getMetaData();
            for (int i = 1; i <= rsmd.getColumnCount(); i++ ) {
                String name = rsmd.getColumnName(i);
                // Do stuff with name
            }
        }
    });

— selins सोफा
स्रोत

0

U, परिणाम नाम से स्तंभ का नाम और मान प्राप्त कर सकता है। MataMataData (); यह कोड मेरे लिए काम करता है:

Connection conn = null;
PreparedStatement preparedStatement = null;
    try {
        Class.forName("com.mysql.cj.jdbc.Driver");
        conn = MySQLJDBCUtil.getConnection();
        preparedStatement = conn.prepareStatement(sql);
        if (params != null) {
            for (int i = 0; i < params.size(); i++) {
                preparedStatement.setObject(i + 1, params.get(i).getSqlValue());
            }
            ResultSet resultSet = preparedStatement.executeQuery();
            ResultSetMetaData md = resultSet.getMetaData();
            while (resultSet.next()) {
                int counter = md.getColumnCount();
                String colName[] = new String[counter];
                Map<String, Object> field = new HashMap<>();
                for (int loop = 1; loop <= counter; loop++) {
                    int index = loop - 1;
                    colName[index] = md.getColumnLabel(loop);
                    field.put(colName[index], resultSet.getObject(colName[index]));
                }
                rows.add(field);
            }
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            }catch (Exception e1) {
                e1.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    return rows;

— 君主不是我
स्रोत

0

मुझे पता है, इस सवाल का जवाब पहले से ही है, लेकिन शायद मेरे जैसे किसी व्यक्ति DatabaseMetaDataको सूचकांक के बजाय लेबल से कॉलम नाम का उपयोग करने की आवश्यकता है :

ResultSet resultSet = null;
DatabaseMetaData metaData = null;

    try {
        metaData  = connection.getMetaData();
        resultSet = metaData.getColumns(null, null, tableName, null);

        while (resultSet.next()){
            String name = resultSet.getString("COLUMN_NAME");
        }
    }

— पावलो रोज्बत्स्की
स्रोत