private static void insertCPI(
      String[] COLUMN_NAMES,
      Connection conn,
      Statement stmt,
      Integer count,
      int batchSize,
      StringBuffer sb,
      CopyManager cpManager,
      PushbackReader reader)
      throws SQLException, ClassNotFoundException {
    // TODO Auto-generated method stub

    Timestamp timestampStart = new Timestamp(System.currentTimeMillis());
    DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    // dateFormat.format(System.currentTimeMillis());
    // System.out.println("dateFormat : "+dateFormat.format(System.currentTimeMillis()));
    System.out.println("count in insertCPI :" + count);

    // CopyManager cpManager = ((PGConnection)conn).getCopyAPI();
    // PushbackReader reader = new PushbackReader( new StringReader(""), 10000 );
    for (int i = 0; i < COLUMN_NAMES.length; i++) {
      if (i == 0) {
        sb.append("").append(COLUMN_NAMES[0]).append(",");
      } else if (i == COLUMN_NAMES.length - 1) {
        COLUMN_NAMES[i] = dateFormat.format(System.currentTimeMillis());
        sb.append(COLUMN_NAMES[i]).append("");
      } else {
        sb.append(COLUMN_NAMES[i]).append(",");
      }
      /**
       * if(i==0){ sb.append("'").append(COLUMN_NAMES[0]).append("','"); } else
       * if(i==COLUMN_NAMES.length-1){ sb.append(COLUMN_NAMES[i]).append("'"); } else {
       * sb.append(COLUMN_NAMES[i]).append("','"); } *
       */
    }
    sb.append("\n");

    System.out.println("insert string :  " + sb.toString());
    if (count % batchSize == 0) {
      try {
        // System.out.println("insert string batch :  "+sb.toString());
        reader.unread(sb.toString().toCharArray());
        cpManager.copyIn("COPY JOB FROM STDIN WITH CSV", reader);
        sb.delete(0, sb.length());
      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    }
  }
  public void record(FeedMessage feedMessage) throws SQLException {

    int numAlerts = 0;
    int numTripUpdates = 0;
    int numVehiclePositions = 0;

    mOpenQueries = 0;

    for (FeedEntity entity : feedMessage.getEntityList()) {
      if (entity.hasAlert()) {
        numAlerts++;
      }

      if (entity.hasTripUpdate()) {
        numTripUpdates++;
      }

      if (entity.hasVehicle()) {
        numVehiclePositions++;
      }
    }

    boolean hasAlerts = numAlerts > 0;
    boolean hasTripUpdates = numTripUpdates > 0;
    boolean hasVehiclePositions = numVehiclePositions > 0;

    mLogger.info(
        String.format(
            "Entities: alerts=%d, updates=%d, positions=%d",
            numAlerts, numTripUpdates, numVehiclePositions));

    mLogger.info("Clearing tables...");

    if (hasAlerts) {
      clearAlertsData();
    }

    if (hasTripUpdates) {
      clearTripUpdatesData();
    }

    if (hasVehiclePositions) {
      clearVehiclePositionsData();
    }

    mLogger.info("Finished clearing tables");

    if (!hasAlerts && !hasTripUpdates && !hasVehiclePositions) {
      mLogger.info("Nothing to record");
      return;
    }

    boolean useCopy = mConnection instanceof BaseConnection;

    CopyManager cm = null;

    DataCopier tuCopier = null;
    DataCopier stCopier = null;
    DataCopier vpCopier = null;

    CopyIn tuCopyIn = null;
    CopyIn stCopyIn = null;
    CopyIn vpCopyIn = null;

    if (useCopy) {
      cm = new CopyManager((BaseConnection) mConnection);
      tuCopier = new DataCopier();
      stCopier = new DataCopier();
      vpCopier = new DataCopier();

      if (hasTripUpdates) {
        stCopyIn = cm.copyIn(COPY_TRIP_UPDATES_STOP_TIMES);
        mOpenQueries++;

        stCopier = new DataCopier(stCopyIn, COPY_SEPARATOR);
      } else if (hasVehiclePositions) {
        vpCopyIn = cm.copyIn(COPY_VEHICLE_POSITIONS);
        mOpenQueries++;

        vpCopier = new DataCopier(vpCopyIn, COPY_SEPARATOR);
      }
    }

    for (FeedEntity entity : feedMessage.getEntityList()) {
      if (entity.hasAlert()) {
        try {
          recordAlert(entity.getAlert());
        } catch (SQLException e) {
          mLogger.warning(getString(e));
        }
      }

      if (entity.hasTripUpdate()) {
        try {
          recordTripUpdate(entity.getTripUpdate(), tuCopier, stCopier);
        } catch (Exception e) {
          mLogger.warning(getString(e));
        }
      }

      if (entity.hasVehicle()) {
        try {
          recordVehicle(entity.getVehicle(), vpCopier);
        } catch (Exception e) {
          mLogger.warning(getString(e));
        }
      }
    }

    if (hasAlerts) {
      mLogger.info("Committing alerts... ");

      try {
        mStatements.get(STALERT).executeBatch();
        mStatements.get(STALERT_ENTITIES).executeBatch();
        mStatements.get(STALERT_TIMERANGES).executeBatch();
        mLogger.info("done");
      } catch (Exception e) {
        mLogger.warning(getString(e));
      }
    }

    if (hasTripUpdates) {
      mLogger.info("Committing trip updates... ");

      try {
        if (stCopier == null) {
          mStatements.get(STTRIPUPDATE_STOPTIMEUPDATES).executeBatch();
        } else if (stCopyIn == null && stCopier.size() > 0) {
          stCopyIn = cm.copyIn(COPY_TRIP_UPDATES_STOP_TIMES);
          mOpenQueries++;

          stCopier.write(stCopyIn, COPY_SEPARATOR);
        }
      } catch (SQLException e) {
        e.printStackTrace();
      }

      if (stCopyIn != null) {
        try {
          stCopyIn.endCopy();
          mOpenQueries--;
        } catch (Exception e) {
          mLogger.warning(getString(e));
        }
      }

      try {
        if (tuCopier == null) {
          mStatements.get(STTRIPUPDATE).executeBatch();
        } else if (tuCopyIn == null && tuCopier.size() > 0) {
          tuCopyIn = cm.copyIn(COPY_TRIP_UPDATES);
          mOpenQueries++;

          tuCopier.write(tuCopyIn, COPY_SEPARATOR);
        }
      } catch (SQLException e) {
        e.printStackTrace();
      }

      if (tuCopyIn != null) {
        try {
          tuCopyIn.endCopy();
          mOpenQueries--;
        } catch (Exception e) {
          mLogger.warning(getString(e));
        }
      }

      mLogger.info("done");
    }

    if (hasVehiclePositions) {
      System.err.print("Committing vehicle positions... ");

      try {
        if (vpCopier == null) {
          mStatements.get(STVEHICLE).executeBatch();
        } else if (vpCopyIn == null && vpCopier.size() > 0) {
          vpCopyIn = cm.copyIn(COPY_VEHICLE_POSITIONS);
          mOpenQueries++;
          vpCopier.write(vpCopyIn, COPY_SEPARATOR);
        }
      } catch (Exception e) {
        mLogger.warning(getString(e));
      }

      if (vpCopyIn != null) {
        vpCopyIn.endCopy();
        mOpenQueries--;
      }

      mLogger.info("done");
    }
  }
Exemplo n.º 3
0
  /** @param args */
  public static void main(String[] args) {

    try {
      Class.forName("org.postgresql.Driver");
    } catch (ClassNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    // Datenbankverbindung aufbauen
    String url = "jdbc:postgresql://localhost/Bundestagswahl?user=user&password=1234";
    Connection conn;
    Statement st;

    ResultSet rs = null;

    // Datenbank neu aufsetzen
    if (setupDatabase) {
      String[] init = {""};
      BWSetupDatabase.main(init);
    }

    // Stimmen pro Wahlkreis aus wkumrechnung200x.csv auslesen
    // und in stimmen200x.csv Einzelstimmen schreiben

    try {
      try {
        conn = DriverManager.getConnection(url);
        st = conn.createStatement();
        CSVReader readerErgebnis[] = new CSVReader[2];
        CSVWriter writerErststimmen[] = new CSVWriter[2];
        CSVWriter writerZweitstimmen[] = new CSVWriter[2];

        if (generateStimmen) {
          readerErgebnis[0] =
              new CSVReader(
                  new BufferedReader(
                      new InputStreamReader(new FileInputStream(ergebnis05Pfad), "UTF-8")),
                  ';');
          readerErgebnis[1] =
              new CSVReader(
                  new BufferedReader(
                      new InputStreamReader(new FileInputStream(ergebnis09Pfad), "UTF-8")),
                  ';');

          writerErststimmen[0] =
              new CSVWriter(
                  new BufferedWriter(
                      new OutputStreamWriter(new FileOutputStream(erststimmen05Pfad), "UTF-8")),
                  ';');
          writerErststimmen[1] =
              new CSVWriter(
                  new BufferedWriter(
                      new OutputStreamWriter(new FileOutputStream(erststimmen09Pfad), "UTF-8")),
                  ';');

          writerZweitstimmen[0] =
              new CSVWriter(
                  new BufferedWriter(
                      new OutputStreamWriter(new FileOutputStream(zweitstimmen05Pfad), "UTF-8")),
                  ';');
          writerZweitstimmen[1] =
              new CSVWriter(
                  new BufferedWriter(
                      new OutputStreamWriter(new FileOutputStream(zweitstimmen09Pfad), "UTF-8")),
                  ';');
        }

        st.executeUpdate("DELETE FROM wahlberechtigte;");

        for (int jahr = 0; jahr < 2; jahr++) {
          String jahrName = Integer.toString(2005 + jahr * 4);

          if (generateStimmen) {
            System.out.println("\nGenerating started");
            String[] readLineErgebnis;

            // Wahlberechtigte Tabelle leeren

            // kerg.csv------------------------------------

            // Anfangszeilen überspringen und Header auslesen

            readerErgebnis[jahr].readNext();
            readerErgebnis[jahr].readNext();
            readLineErgebnis = readerErgebnis[jahr].readNext();
            readerErgebnis[jahr].readNext();
            readerErgebnis[jahr].readNext();

            // Beschriftung einlesen und Spalten Parteien zuordnen
            HashMap<Integer, String> parteienSpalte = new HashMap<Integer, String>();
            for (int i = 19; i < 132; i = i + 4) {
              parteienSpalte.put(i, readLineErgebnis[i]);
            }

            // Benötige Variablen
            int erststimmzettelnummer = 1;
            int zweitstimmzettelnummer = 1;

            int aktuelleKandidatennummer = 0;
            int aktuelleParteinummer = 0;

            while ((readLineErgebnis = readerErgebnis[jahr].readNext()) != null) {

              if (!readLineErgebnis[0].trim().equals("")
                  && !readLineErgebnis[2].trim().equals("")
                  && !readLineErgebnis[2].equals("99")) {

                int wahlkreisnummer = Integer.parseInt(readLineErgebnis[0]);

                String wahlkreisname = readLineErgebnis[1];
                System.out.println("\n" + wahlkreisnummer + " - " + wahlkreisname); // Ladebalken

                int wahlberechtigte = Integer.parseInt(readLineErgebnis[3]);

                System.out.println(wahlberechtigte);

                int aktelleBundeslandnummer =
                    Integer.parseInt(
                        getQueryResult(
                            st,
                            rs,
                            "SELECT bundesland FROM wahlkreis WHERE jahr = "
                                + jahrName
                                + " AND wahlkreisnummer = "
                                + wahlkreisnummer
                                + ";"));

                // Wahlberechtigte einf�gen
                st.executeUpdate(
                    "INSERT INTO wahlberechtigte VALUES ("
                        + jahrName
                        + ","
                        + wahlkreisnummer
                        + ","
                        + wahlberechtigte
                        + ");");

                for (int i = 19; i < 132; i = i + 4) {

                  System.out.print("."); // Ladebalken

                  String partei = parteienSpalte.get(i);

                  int erststimmenAnzahl = 0;
                  int zweitstimmenAnzahl = 0;

                  if (!readLineErgebnis[i].equals(""))
                    erststimmenAnzahl = Integer.parseInt(readLineErgebnis[i]);

                  if (!readLineErgebnis[i + 2].equals(""))
                    zweitstimmenAnzahl = Integer.parseInt(readLineErgebnis[i + 2]);

                  aktuelleParteinummer =
                      Integer.parseInt(
                          getQueryResult(
                              st,
                              rs,
                              "SELECT parteinummer FROM partei WHERE name = '" + partei + "';"));

                  if (zweitstimmenAnzahl > 0) {

                    for (int j = 0; j < zweitstimmenAnzahl; j++) {
                      String[] writeLine = {
                        jahrName,
                        Integer.toString(zweitstimmzettelnummer),
                        Integer.toString(aktuelleParteinummer),
                        Integer.toString(wahlkreisnummer),
                        Integer.toString(aktelleBundeslandnummer)
                      };

                      writerZweitstimmen[jahr].writeNext(writeLine);
                      zweitstimmzettelnummer++;
                    }
                  }

                  if (erststimmenAnzahl > 0) {
                    aktuelleKandidatennummer =
                        Integer.parseInt(
                            getQueryResult(
                                st,
                                rs,
                                "SELECT kandidatennummer FROM direktkandidat WHERE jahr = "
                                    + jahrName
                                    + " AND wahlkreis = "
                                    + wahlkreisnummer
                                    + " AND partei = "
                                    + aktuelleParteinummer
                                    + ";"));

                    for (int j = 0; j < erststimmenAnzahl; j++) {
                      String[] writeLine = {
                        jahrName,
                        Integer.toString(erststimmzettelnummer),
                        Integer.toString(aktuelleKandidatennummer),
                        Integer.toString(wahlkreisnummer)
                      };

                      writerErststimmen[jahr].writeNext(writeLine);
                      erststimmzettelnummer++;
                    }
                  }
                }
              }
            }
            writerZweitstimmen[jahr].close();

            writerErststimmen[jahr].close();
            readerErgebnis[jahr].close();

            System.out.println("\nGenerating finished");
          }

          SimpleDateFormat format = new SimpleDateFormat("hh:mm:ss");
          if (loadStimmen) {

            // Bulk Load der
            // ErstStimmen----------------------------------------
            CopyManager copyManager = new CopyManager((BaseConnection) conn);
            String actPfad;
            String progressString;
            String talbeDestination;
            for (int stimme = 0; stimme < 2; stimme++) {
              System.out.println("\nCopying started: " + format.format(new Date()));

              switch (stimme) {
                case 0:
                  talbeDestination = "erststimme";
                  switch (jahr) {
                    case 0:
                      actPfad = erststimmen05Pfad;
                      progressString = "Erststimmen 2005 laden";
                      break;
                    default:
                      actPfad = erststimmen09Pfad;
                      progressString = "Erststimmen 2009 laden";
                      break;
                  }
                  break;
                default:
                  talbeDestination = "zweitstimme";
                  switch (jahr) {
                    case 0:
                      actPfad = zweitstimmen05Pfad;
                      progressString = "Zweitstimmen 2005 laden";
                      break;
                    default:
                      actPfad = zweitstimmen09Pfad;
                      progressString = "Zweitstimmen 2009 laden";
                      break;
                  }
                  break;
              }

              System.out.println(talbeDestination + "   " + actPfad);
              InputStream in =
                  new BufferedInputStream(
                      CopyProgressMonitor.getCopyProgressMonitor(actPfad, progressString));
              copyManager.copyIn(
                  "COPY " + talbeDestination + " FROM STDIN WITH DELIMITER ';' CSV", in);

              System.out.println("\nCopying finished");
            }
          }
          if (addConstraints) {
            System.out.println("\nAdding Constraints");

            try {
              st.executeUpdate(
                  "ALTER TABLE wahlberechtigte  ADD CONSTRAINT wahlkreis FOREIGN KEY (jahr,wahlkreis) REFERENCES wahlkreis(jahr,wahlkreisnummer);");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE direktkandidat  ADD CONSTRAINT politiker FOREIGN KEY (politiker) REFERENCES politiker;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE direktkandidat  ADD CONSTRAINT partei FOREIGN KEY (partei) REFERENCES partei;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE direktkandidat  ADD CONSTRAINT wahlkreis FOREIGN KEY (jahr,wahlkreis) REFERENCES wahlkreis(jahr,wahlkreisnummer);");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE listenkandidat  ADD CONSTRAINT partei FOREIGN KEY (partei) REFERENCES partei;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE listenkandidat  ADD CONSTRAINT bundesland FOREIGN KEY (bundesland) REFERENCES bundesland;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE listenkandidat  ADD CONSTRAINT politiker FOREIGN KEY (politiker) REFERENCES politiker;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE erststimme  ADD CONSTRAINT kandidatennummer FOREIGN KEY (kandidatennummer) REFERENCES direktkandidat(kandidatennummer);");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE zweitstimme  ADD CONSTRAINT bundesland FOREIGN  KEY (bundesland) REFERENCES bundesland;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE zweitstimme  ADD CONSTRAINT partei FOREIGN  KEY (partei) REFERENCES partei;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE erststimmen  ADD CONSTRAINT kandidatennummer FOREIGN  KEY (kandidatennummer) REFERENCES direktkandidat(kandidatennummer);");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            try {
              st.executeUpdate(
                  "ALTER TABLE zweitstimmen  ADD CONSTRAINT partei FOREIGN  KEY (partei) REFERENCES partei;");
            } catch (SQLException e) {
              e.printStackTrace();
            }
            System.out.println("\nFinished");
          }
        }

        // Stimmen aggregieren
        if (false) {
          System.out.println("\n Aggregate Stimmen");

          try {
            st.executeUpdate("DELETE FROM erststimmen;");
            st.executeUpdate("DELETE FROM zweitstimmen;");
            st.executeUpdate(
                "INSERT INTO erststimmen SELECT jahr, wahlkreis, kandidatennummer, count(*) as anzahl  FROM erststimme GROUP BY wahlkreis, kandidatennummer,jahr ORDER BY wahlkreis, anzahl;");
            st.executeUpdate(
                "INSERT INTO zweitstimmen SELECT jahr, wahlkreis, partei, count(*) as anzahl  FROM zweitstimme GROUP BY wahlkreis, partei,jahr ORDER BY wahlkreis, anzahl;");

          } catch (SQLException e) {
            e.printStackTrace();
          }

          // printQueryResult(st, rs, "zweitstimmen");
          // printQueryResult(st, rs, "erststimmen");

          System.out.println("\nFinished");
        }

        // Parameter f�r Queries, �ber UI auszuw�hlen:
        String jahrName = "2005";
        int wahlkreis = 1;

        // Initialize the service proxy.

        long millis = System.currentTimeMillis();

        // Q4: Wahlkreissieger (Q3 ben�tigt View aus Q4)
        System.out.println("\n Q4: Wahlkreissieger");

        try {
          st.executeUpdate(
              "CREATE OR REPLACE VIEW erststimmengewinner AS SELECT  s1.wahlkreis, s1.kandidatennummer, s1.anzahl FROM erststimmen s1 , wahlkreis w WHERE s1.jahr = "
                  + jahrName
                  + " AND w.jahr = "
                  + jahrName
                  + " AND s1.wahlkreis = w.wahlkreisnummer AND s1.anzahl = ( SELECT max(s2.anzahl) FROM erststimmen s2 WHERE s2.jahr = "
                  + jahrName
                  + " AND s2.wahlkreis = w.wahlkreisnummer)");
          st.executeUpdate(
              "CREATE OR REPLACE VIEW zweitstimmengewinner AS SELECT s1.wahlkreis, s1.partei, s1.anzahl FROM zweitstimmen s1 , wahlkreis w WHERE s1.jahr = "
                  + jahrName
                  + " AND w.jahr = "
                  + jahrName
                  + " AND s1.wahlkreis = w.wahlkreisnummer AND s1.anzahl = ( SELECT max(s2.anzahl) FROM zweitstimmen s2 WHERE s2.jahr = "
                  + jahrName
                  + " AND s2.wahlkreis = w.wahlkreisnummer)");

        } catch (SQLException e) {
          e.printStackTrace();
        }

        // printQueryResult(st, rs, "erststimmengewinner");
        // printQueryResult(st, rs, "zweitstimmengewinner");

        System.out.println("\nQ4 Finished: " + (System.currentTimeMillis() - millis));
        millis = System.currentTimeMillis();
        // Q2: Mitglieder des Bundestages
        System.out.println("\n Q2: Mitglieder des Bundestages");
        st.executeUpdate(
            "CREATE OR REPLACE VIEW mitgliedererststimme AS "
                + "SELECT d.politiker , d.partei FROM erststimmengewinner esg, direktkandidat d WHERE esg.kandidatennummer = d.kandidatennummer");

        // st.executeUpdate("CREATE OR REPLACE VIEW mitglieder AS("
        // + "WITH verteilung AS ( "
        // + "	SELECT * "
        // + "	FROM erststimmenergebnis  "
        // + "  union all "
        // + " 	SELECT * "
        // + " 	FROM zweitstimmenergebnis)"
        // +
        // "SELECT lk.politiker, lk.partei   FROM Listenkandidat lk,verteilung v, partei pa WHERE
        // pa.name =  v.parteiname AND lk.partei = pa.parteinummer  AND lk.listenplatz <= v.sitze-
        // (SELECT count(*) FROM mitgliedererststimme mes WHERE mes.partei = pa.parteinummer )"
        // + "UNION SELECT * FROM mitgliedererststimme )");

        System.out.println("\nQ2 Finished: " + (System.currentTimeMillis() - millis));
        millis = System.currentTimeMillis();
        // Q3: Wahlkreis�bersicht
        System.out.println("\n Q3: Wahlkreis�bersicht");

        try {
          st.executeUpdate(
              "CREATE OR REPLACE VIEW wahlbeteiligungabsolut AS "
                  + "SELECT sum(anzahl) FROM erststimmen WHERE jahr = "
                  + jahrName
                  + " AND wahlkreis = "
                  + wahlkreis);

          st.executeUpdate(
              "CREATE OR REPLACE VIEW wahlbeteiligungrelativ AS "
                  + "SELECT (SELECT * FROM wahlbeteiligungabsolut) / (  SELECT wahlberechtigte FROM wahlberechtigte WHERE jahr = "
                  + jahrName
                  + " AND wahlkreis = "
                  + wahlkreis
                  + " )::float ;");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW erststimmengewinnerkandidat AS "
                  + "SELECT name FROM politiker p , direktkandidat d WHERE p.politikernummer = d.politiker AND d.kandidatennummer = (SELECT e.kandidatennummer FROM erststimmengewinner e ORDER BY RANDOM() LIMIT 1)");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilabsolut AS "
                  + "SELECT p.parteinummer as parteinummer, (SELECT sum(zs.anzahl) FROM zweitstimmen zs WHERE zs.jahr = "
                  + jahrName
                  + " AND zs.partei =  p.parteinummer) as anzahl  FROM partei p");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilrelativ AS "
                  + "SELECT pa.parteinummer as parteinummer, pa.anzahl/(SELECT * FROM wahlbeteiligungabsolut) as anteil FROM parteinenanteilabsolut pa ");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilabsolutvorjahr AS "
                  + "SELECT p.parteinummer, (SELECT sum(zs.anzahl) FROM zweitstimmen zs WHERE zs.jahr = "
                  + Integer.toString(Integer.parseInt(jahrName) - 4)
                  + " AND zs.partei =  p.parteinummer) as anzahl  FROM partei p");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilveraenderung AS "
                  + "SELECT pa1.parteinummer as parteinummer , pa1.anzahl-pa2.anzahl as anzahl FROM parteinenanteilabsolutvorjahr pa2, parteinenanteilabsolut pa1 WHERE pa1.parteinummer = pa2.parteinummer");

        } catch (SQLException e) {
          e.printStackTrace();
        }

        // printQueryResult(st, rs, "wahlbeteiligungabsolut");
        // printQueryResult(st, rs, "wahlbeteiligungrelativ");
        // printQueryResult(st, rs, "erststimmengewinnerkandidat");
        // printQueryResult(st, rs, "parteinenanteilabsolut");
        // printQueryResult(st, rs, "parteinenanteilrelativ");
        // printQueryResult(st, rs, "parteinenanteilabsolutvorjahr");
        // printQueryResult(st, rs, "parteinenanteilveraenderung");

        System.out.println("\nQ4 Finished: " + (System.currentTimeMillis() - millis));
        millis = System.currentTimeMillis();
        // Q5: �berhangmandate
        System.out.println("\n Q5: �berhangmandate");

        st.executeUpdate(
            "CREATE OR REPLACE VIEW ueberhangmandate AS "
                + "SELECT pes.parteiname, pes.sitze - pzs.sitze FROM erststimmenergebnis pes, zweitstimmenergebnis pzs WHERE pzs.parteiname = pes.parteiname AND (pes.sitze - pzs.sitze) > 0 ");

        System.out.println("\nQ5 Finished: " + (System.currentTimeMillis() - millis));
        millis = System.currentTimeMillis();
        // Q6: Knappster Sieger
        System.out.println("\n Q6: Knappster Sieger");

        try {
          st.executeUpdate(
              "CREATE OR REPLACE VIEW knappstegewinner AS "
                  + "SELECT s1.wahlkreis, s1.kandidatennummer, d.partei , "
                  + "( SELECT min(s1.anzahl - s2.anzahl) FROM erststimmen s2 WHERE jahr = "
                  + jahrName
                  + " AND s1.anzahl - s2.anzahl > 0 AND s1.wahlkreis = s2.wahlkreis AND s1.kandidatennummer != s2.kandidatennummer) AS differenz"
                  + " FROM erststimmen s1 , direktkandidat d WHERE s1.jahr = "
                  + jahrName
                  + " AND d.jahr = "
                  + jahrName
                  + " AND s1.kandidatennummer = d.kandidatennummer");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW knappsteergebnisse AS "
                  + "(SELECT * FROM knappstegewinner ) UNION "
                  + "(SELECT s1.wahlkreis, s1.kandidatennummer, d.partei , "
                  + " ( SELECT min( differenz ) FROM ( SELECT (s2.anzahl - s1.anzahl) As differenz FROM erststimmen s2 WHERE jahr = "
                  + jahrName
                  + " AND s2.wahlkreis = s1.wahlkreis AND ( s2.anzahl - s1.anzahl ) > 0 ) AS ergebnissedifferenzen )"
                  + " FROM erststimmen s1 , direktkandidat d WHERE s1.jahr = "
                  + jahrName
                  + " AND d.jahr = "
                  + jahrName
                  + " AND s1.kandidatennummer = d.kandidatennummer AND d.partei NOT IN ( SELECT k.partei from knappstegewinner k) )");

        } catch (SQLException e) {
          e.printStackTrace();
        }

        // printQueryResult(st, rs, "knappstegewinner");
        // printQueryResult(st, rs, "knappsteergebnisse");

        System.out.println("\nQ6 Finished: " + (System.currentTimeMillis() - millis));
        millis = System.currentTimeMillis();
        // Q7: Wahlkreisübersicht (Einzelstimmen)
        System.out.println("\n Q7: Wahlkreisübersicht (Einzelstimmen)");

        try {
          st.executeUpdate(
              "CREATE OR REPLACE VIEW wahlbeteiligungabsoluteinzelstimmen AS "
                  + "SELECT sum(anzahl) FROM (SELECT jahr, wahlkreis, kandidatennummer, count(*) as anzahl  FROM erststimme GROUP BY wahlkreis, kandidatennummer,jahr) AS stimmen WHERE jahr = "
                  + jahrName
                  + " AND wahlkreis = "
                  + wahlkreis);

          st.executeUpdate(
              "CREATE OR REPLACE VIEW wahlbeteiligungrelativeinzelstimmen AS "
                  + "SELECT (SELECT * FROM wahlbeteiligungabsoluteinzelstimmen) / (  SELECT wahlberechtigte FROM wahlberechtigte WHERE jahr = "
                  + jahrName
                  + " AND wahlkreis = "
                  + wahlkreis
                  + " )::float ;");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW erststimmengewinnerkandidateinzelstimmen AS "
                  + "SELECT name FROM politiker p , direktkandidat d WHERE p.politikernummer = d.politiker AND d.kandidatennummer = (SELECT e.kandidatennummer FROM (SELECT  s1.wahlkreis, s1.kandidatennummer, s1.anzahl FROM ( SELECT jahr, wahlkreis, kandidatennummer, count(*) as anzahl  FROM erststimme GROUP BY wahlkreis, kandidatennummer,jahr) s1 , wahlkreis w WHERE s1.jahr = "
                  + jahrName
                  + " AND w.jahr = "
                  + jahrName
                  + " AND s1.wahlkreis = w.wahlkreisnummer AND s1.anzahl = (SELECT max(s2.anzahl) FROM ( SELECT jahr, wahlkreis, kandidatennummer, count(*) as anzahl  FROM erststimme GROUP BY wahlkreis, kandidatennummer,jahr) s2 WHERE s2.jahr = "
                  + jahrName
                  + " AND s2.wahlkreis = w.wahlkreisnummer)) e ORDER BY RANDOM() LIMIT 1)");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilabsoluteinzelstimmen AS "
                  + "SELECT p.parteinummer as parteinummer, (SELECT sum(zs.anzahl) FROM (SELECT jahr, wahlkreis, partei, count(*) as anzahl  FROM zweitstimme GROUP BY wahlkreis, partei,jahr) zs WHERE zs.jahr = "
                  + jahrName
                  + " AND zs.partei =  p.parteinummer) as anzahl  FROM partei p");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilrelativeinzelstimmen AS "
                  + "SELECT pa.parteinummer as parteinummer, pa.anzahl/(SELECT * FROM wahlbeteiligungabsoluteinzelstimmen) as anteil FROM parteinenanteilabsoluteinzelstimmen pa ");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilabsolutvorjahreinzelstimmen AS "
                  + "SELECT p.parteinummer, (SELECT sum(zs.anzahl) FROM (SELECT jahr, wahlkreis, partei, count(*) as anzahl  FROM zweitstimme GROUP BY wahlkreis, partei,jahr) zs WHERE zs.jahr = "
                  + Integer.toString(Integer.parseInt(jahrName) - 4)
                  + " AND zs.partei =  p.parteinummer) as anzahl  FROM partei p");

          st.executeUpdate(
              "CREATE OR REPLACE VIEW parteinenanteilveraenderungeinzelstimmen AS "
                  + "SELECT pa1.parteinummer as parteinummer , pa1.anzahl-pa2.anzahl as anzahl FROM parteinenanteilabsolutvorjahreinzelstimmen pa2, parteinenanteilabsoluteinzelstimmen pa1 WHERE pa1.parteinummer = pa2.parteinummer");

        } catch (SQLException e) {
          e.printStackTrace();
        }

        printQueryResult(st, rs, "wahlbeteiligungabsoluteinzelstimmen");
        printQueryResult(st, rs, "wahlbeteiligungrelativeinzelstimmen");
        printQueryResult(st, rs, "erststimmengewinnerkandidateinzelstimmen");
        printQueryResult(st, rs, "parteinenanteilabsoluteinzelstimmen");
        printQueryResult(st, rs, "parteinenanteilrelativeinzelstimmen");
        printQueryResult(st, rs, "parteinenanteilabsolutvorjahreinzelstimmen");
        printQueryResult(st, rs, "parteinenanteilveraenderungeinzelstimmen");

        System.out.println("\nQ7 Finished: " + (System.currentTimeMillis() - millis));

        st.close();
        conn.close();

      } catch (SQLException e) {
        e.printStackTrace();
      }
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Exemplo n.º 4
0
  @SuppressWarnings("unchecked")
  private void vcsCopy() {

    Map<String, byte[]> file = (Map<String, byte[]>) ThreadMail.get("csv_file");
    long rule = (long) ThreadMail.get("rule");
    String view_name = (String) ThreadMail.get("view_name");

    CopyManager copyManager = null;
    String bytesAsString = null;
    StringReader readers = null;
    BufferedReader reader = null;
    String line = null;
    String format = "";
    String Sql = "";
    String dropview = "";
    String field = "";
    try {

      copyManager = new CopyManager(getCon().unwrap(BaseConnection.class));
    } catch (SQLException e2) {
      // TODO Auto-generated catch block
      e2.printStackTrace();
      return;
    }

    for (String key : file.keySet()) {

      try {
        bytesAsString = new String(file.get(key), "UTF-8");
      } catch (UnsupportedEncodingException e1) {
        // TODO Auto-generated catch block
        // e1.printStackTrace();
        echo("error file get string");
        return;
      }
      if (bytesAsString == null) return;
      readers = new StringReader(bytesAsString);
      reader = new BufferedReader(readers);
      try {
        line = reader.readLine();
        line = line.replace(" ", "_");

        dropview = "drop view if exists " + view_name;
        try {
          dbcreate(dropview);
        } catch (SQLException e1) {
          // TODO Auto-generated catch block
          e1.printStackTrace();
        }

        String[] lines = line.split(",");
        String act = "";
        String asName = "";
        for (int m = 0; m < lines.length; m++) {
          act = "act_v" + Integer.toHexString(m);
          asName += act + " as " + lines[m] + ",";
          field += act + ", ";
        }
        field = field.trim();
        field = field.substring(0, field.length() - 1);
        asName = asName.substring(0, asName.length() - 1);

        if (copyManager != null) {
          copyManager.copyIn(
              "COPY " + DB_HOR_PRE + "class (" + field + ") FROM STDIN DELIMITER ',' ", reader);
        }

        format = "CREATE VIEW %s AS SELECT %s FROM " + DB_HOR_PRE + "class WHERE rule=%d";
        Sql = String.format(format, view_name, asName, rule);

        dbcreate(Sql);

        Sql = "update " + DB_HOR_PRE + "class  set rule=" + rule + " where rule=0";

        update(Sql);

      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }

      echo("Done.");
    }
  }
  /**
   * @param args
   * @throws IOException
   */
  public static void main(String[] args) throws ClassNotFoundException, SQLException, IOException {
    // TODO Auto-generated method stub
    String jdbcURL =
        "jdbc:postgresql://trinity0415.cbcslkvnswmn.us-west-1.rds.amazonaws.com/trinityaws";
    String user = "******";
    String pwd = "trinity123";
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;
    final int batchSize = 5;
    Integer count = 0;
    int i, j;

    final String[] COLUMN_NAMES =
        new String[] {
          "", // "jobuid", 0
          "", // "JobName", 1
          "", // "Description", 2
          "1", // "Activate",  3
          "default", // "DomainUID",    4
          "", // "categoryuid",  5, need to update for category changed.
          "", // "agentuid", 6
          "", // "FrequencyUID", 7
          "", // "FileSourceUID", 8
          "1", // "JobType", 9
          "0", // "Retry",10
          "1", // "RetryInterval",11
          "1", // "MaxRetryTime",12
          "0", // "RetryMode",13
          "1", // "Priority",14
          "1", // "TimeWindowBegin",15
          "1439", // "TimeWindowEnd",16
          "0", // "TxDateRule",17
          "0", // "TxOffsetDay",18
          "1", // "BypassError",19
          "O", // "status",20
          "0", // "CriticalJob",21
          "trinity", // "createuseruid",22
          "", // "XMLData",23
          "", // "OnlineDateTime",24
          "", // "OfflineDateTime",25
          "", // refjobuid character varying(36),26
          "", // lastupdatetime timestamp without time zone DEFAULT now(),
        };

    try {
      Class.forName("org.postgresql.Driver");
      conn = DriverManager.getConnection(jdbcURL, user, pwd);
      conn.setAutoCommit(false);
      System.out.println("connected");

      Date date = new Date();
      System.out.println("Date : " + date);

      // Creating statement for db activities
      stmt = conn.createStatement();

      // select jobcategory uid
      String query1 = "SELECT distinct categoryuid FROM JOBCATEGORY";
      rs = stmt.executeQuery(query1);
      while (rs.next()) COLUMN_NAMES[5] = rs.getString("categoryuid");

      // select AGENT uid
      String query2 = "SELECT distinct agentuid FROM JCSAGENT";
      rs = stmt.executeQuery(query2);
      while (rs.next()) COLUMN_NAMES[6] = rs.getString("agentuid");

      String query3 = "SELECT distinct categoryuid, agentuid, JobName, xmldata FROM JOB";

      rs = stmt.executeQuery(query3);

      while (rs.next()) {
        COLUMN_NAMES[1] = rs.getString("JobName");
        COLUMN_NAMES[23] = rs.getString("xmldata");
        count++;
      }
      // StringBuffer sb=new StringBuffer("JobUID,JobName,
      // Description,Activate,DomainUID,categoryuid,  agentuid, FrequencyUID, FileSourceUID,
      // JobType,
      // Retry,RetryInterval,MaxRetryTime,RetryMode,Priority,TimeWindowBegin,TimeWindowEnd,TxDateRule,TxOffsetDay,BypassError,status,CriticalJob,createuseruid,XMLData,OnlineDateTime,OfflineDateTime");
      StringBuffer sb = new StringBuffer();
      Timestamp timestampStart = new Timestamp(System.currentTimeMillis());
      CopyManager cpManager = ((PGConnection) conn).getCopyAPI();
      PushbackReader reader = new PushbackReader(new StringReader(""), 10000);
      while (count < 30) {
        count++;

        COLUMN_NAMES[1] = "job";
        COLUMN_NAMES[0] = UUID.randomUUID().toString();
        // COLUMN_NAMES[0]=UUID.randomUUID().toString().replaceAll("[\\W]|_", "");
        COLUMN_NAMES[1] = COLUMN_NAMES[1] + count;
        // COLUMN_NAMES[2]=dateFormat.format(System.currentTimeMillis());

        // insertVSI(COLUMN_NAMES,conn, stmt);
        insertCPI(COLUMN_NAMES, conn, stmt, count, batchSize, sb, cpManager, reader);
        insertMultiStepFromJobUid.main(COLUMN_NAMES); // call jobstep here.
      }
      reader.unread(sb.toString().toCharArray());
      cpManager.copyIn("COPY JOB FROM STDIN WITH CSV", reader);

      conn.commit();

      Timestamp timestampEnd = new Timestamp(System.currentTimeMillis());
      System.out.println("time elapsed : " + (timestampEnd.getTime() - timestampStart.getTime()));
    } finally {
      if (conn != null) {
        System.out.println("[job]connection closed!");
        // clean(conn);
        conn.close();
      }
    }
  }