Sqlite get table3

.gitignore

@@ -0,0 +1,6 @@
+.bench
+CMakeCache.txt
+CMakeFiles
+Makefile
+cmake_install.cmake
+test.db*

CMakeLists.txt

@@ -38,9 +38,10 @@ else()
   message("Could not find HPX. Configuring without HPX support.")
 endif()
 
-set(EXTRA_LIBS pthread)
+set(EXTRA_LIBS pthread sqlite3)
 
-#find_package(Readline)
+find_package(Readline)
+find_package(SQLite3)
 
 if(READLINE_FOUND)
   message("Readline was found.")

cmake/FindSQLite3.cmake

@@ -0,0 +1,87 @@
+# - Try to find Sqlite3
+# Once done this will define
+#
+#  SQLITE3_FOUND - system has Sqlite3
+#  SQLITE3_INCLUDE_DIRS - the Sqlite3 include directory
+#  SQLITE3_LIBRARIES - Link these to use Sqlite3
+#  SQLITE3_DEFINITIONS - Compiler switches required for using Sqlite3
+#
+#  Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
+#
+#  Redistribution and use is allowed according to the terms of the New
+#  BSD license.
+#  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
+#
+
+
+if (SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS)
+  # in cache already
+  set(SQLITE3_FOUND TRUE)
+else (SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS)
+  # use pkg-config to get the directories and then use these values
+  # in the FIND_PATH() and FIND_LIBRARY() calls
+  if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+    include(UsePkgConfig)
+    pkgconfig(sqlite3 _SQLITE3_INCLUDEDIR _SQLITE3_LIBDIR _SQLITE3_LDFLAGS _SQLITE3_CFLAGS)
+  else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+    find_package(PkgConfig)
+    if (PKG_CONFIG_FOUND)
+      pkg_check_modules(_SQLITE3 sqlite3)
+    endif (PKG_CONFIG_FOUND)
+  endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+  find_path(SQLITE3_INCLUDE_DIR
+    NAMES
+      sqlite3.h
+    PATHS
+      ${_SQLITE3_INCLUDEDIR}
+      /usr/include
+      /usr/local/include
+      /opt/local/include
+      /sw/include
+  )
+
+  find_library(SQLITE3_LIBRARY
+    NAMES
+      sqlite3
+    PATHS
+      ${_SQLITE3_LIBDIR}
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib
+  )
+
+  if (SQLITE3_LIBRARY)
+    set(SQLITE3_FOUND TRUE)
+  endif (SQLITE3_LIBRARY)
+
+  set(SQLITE3_INCLUDE_DIRS
+    ${SQLITE3_INCLUDE_DIR}
+  )
+
+  if (SQLITE3_FOUND)
+    set(SQLITE3_LIBRARIES
+      ${SQLITE3_LIBRARIES}
+      ${SQLITE3_LIBRARY}
+    )
+  endif (SQLITE3_FOUND)
+
+  if (SQLITE3_INCLUDE_DIRS AND SQLITE3_LIBRARIES)
+     set(SQLITE3_FOUND TRUE)
+  endif (SQLITE3_INCLUDE_DIRS AND SQLITE3_LIBRARIES)
+
+  if (SQLITE3_FOUND)
+    if (NOT Sqlite3_FIND_QUIETLY)
+      message(STATUS "Found Sqlite3: ${SQLITE3_LIBRARIES}")
+    endif (NOT Sqlite3_FIND_QUIETLY)
+  else (SQLITE3_FOUND)
+    if (Sqlite3_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find Sqlite3")
+    endif (Sqlite3_FIND_REQUIRED)
+  endif (SQLITE3_FOUND)
+
+  # show the SQLITE3_INCLUDE_DIRS and SQLITE3_LIBRARIES variables only in the advanced view
+  mark_as_advanced(SQLITE3_INCLUDE_DIRS SQLITE3_LIBRARIES)
+
+endif (SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS)
+

harness_helgrind.pl

@@ -1,3 +1,4 @@
+#!/usr/bin/perl
 ################################################################################
 ##  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 ##

harness_memcheck.pl

@@ -1,3 +1,4 @@
+#!/usr/bin/perl
 ################################################################################
 ##  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 ##

harness_plain.pl

@@ -1,3 +1,4 @@
+#!/usr/bin/perl
 ################################################################################
 ##  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 ##
@@ -95,7 +96,7 @@
 
 for(my $ply=4;$ply<=6;$ply++) {
     for(my $b=1;$b<=4;$b++) {
-        for my $sm (("minimax","alphabeta","mtdf")) {
+        for my $sm (("alphabeta")) {
             # It takes too long for minimax above ply 4
             # So I ran it once at 5 to verify the answer
             # and then introduced this next.
@@ -132,6 +133,7 @@
                 $cmd="CHX_THREADS_PER_PROC=$threads $mem $chx < .bench|";
             }
             print "cmd=$cmd\n";
+            system("rm -f test.db");
             open($fd,$cmd);
             my $ans = "";
             my $score = $bad_score;

headers/chess_move.hpp

@@ -9,6 +9,7 @@
 #define CHESS_MOVE_HPP_C1BEDE43_B47B_4694_ACF4_F41143D72B97
 
 #include <stdint.h>
+#include <string>
 /* This is the basic description of a chess_move. promote is what
    piece to promote the pawn to, if the chess_move is a pawn
    promotion. bits is a bitfield that describes the chess_move,
@@ -54,10 +55,10 @@ class chess_move {
         u = ((from & 0xFF) << 24) + ((to & 0xFF) << 16) + ((promote & 0xFF) << 8)
             + ((bits & 0xFF) << 0);
     }
-    uint8_t getFrom() { return from; }
-    uint8_t getTo() { return to; }
-    uint8_t getPromote() { return promote; }
-    uint8_t getBits() { return bits; }
+    uint8_t getFrom()    const { return from; }
+    uint8_t getTo()      const { return to; }
+    uint8_t getPromote() const { return promote; }
+    uint8_t getBits()    const { return bits; }
     uint8_t getCapture() const {
         return (bits & 1) != 0;
     }
@@ -95,6 +96,8 @@ class chess_move {
         ar & this->promote;
         ar & this->bits;
     }
+    std::string str() const;
+    std::string pgn() const;
 };
 
 #endif

headers/database.hpp

@@ -0,0 +1,202 @@
+#ifndef DATABASE_H
+#define DATABASE_H
+#include <sstream>
+#include <iostream>
+#include "hash.hpp"
+#include "node.hpp"
+#include "data.hpp"
+#include "defs.hpp"
+#include "chess_move.hpp"
+#include "sqlite3.h"
+#include "main.hpp"
+
+using namespace std;
+
+class database {
+  public:
+    sqlite3 *db;
+    char *zErrMsg=0;
+    int rc;
+
+
+    database(){
+        const char *sql;
+        rc = sqlite3_open("test.db", &db);
+        if( rc ){
+        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
+         exit(0);
+        }else{
+          fprintf(stderr, "Opened database successfully\n");
+        }
+        /* Create SQL statement */
+        sql = "CREATE TABLE MoveSet("  \
+        "PLY              INTEGER     NOT NULL," \
+        "BOARD               TEXT     NOT NULL,"\
+        "HI               NUMERIC(20) NOT NULL,"\
+        "LO               NUMERIC(20) NOT NULL,"\
+        "HASH             INTEGER     NOT NULL,"\
+        "PRIMARY KEY (PLY, BOARD));"; 
+       //Execute SQL statement 
+        rc = sqlite3_exec(db, sql, 0, 0, &zErrMsg);
+        if( rc != SQLITE_OK ){
+            fprintf(stderr, "%s\n", zErrMsg);
+            sqlite3_free(zErrMsg);
+        }else{
+            fprintf(stdout, "Table created successfully\n");
+        }
+//	deleteAll();
+    };
+
+//destructor
+    ~database(){
+      get_data();
+      sqlite3_close(db);
+      cout<<"database closed. \n";
+    }
+
+    void deleteAll(){
+	const char *sql; 
+	std::ostringstream o;
+	o<<"delete from \"MoveSet\"";
+	std::string result = o.str();
+	sql=result.c_str();
+	rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
+	if ( rc == SQLITE_OK) cout<<"MoveSet sucessfully reset";	
+        else{ cout<<zErrMsg<<"/n"; sqlite3_free(zErrMsg);}
+	}
+
+    void add_data(const node_t& board, score_t lo, score_t hi){
+      int ply = board.depth;
+      auto hash= board.hash;
+      const char *sql;    //maybe find a way to make work without const
+      //create SQL statement from string into char * array
+      std::ostringstream bsm;
+      print_board(board,bsm,true);
+      std::string bs = bsm.str();
+
+      std::ostringstream o;
+
+      o<< "INSERT OR REPLACE INTO \"MoveSet\"VALUES ("<<ply<<",'"<<bs<<"',"<<hi<<","<<lo<<","<<hash<<");";
+      std::string result = o.str();
+      sql=result.c_str();
+      //char *sql = "REPLACE INTO \"MOVELIST\"VALUES (69,0);";
+      //"INSERT INTO \"MOVELIST\"VALUES (66,0);";
+      //execute SQL statement
+      rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
+      if ( rc!= SQLITE_OK ){
+        fprintf(stderr, "SQL error: %s\n", zErrMsg);
+        sqlite3_free(zErrMsg);
+      }else{
+        //fprintf(stdout, "Records created sucessfully\n");
+      }     
+    }
+//look for boards that are the same, look for boards >= to current depth, most importantly score greater than the current score
+    int get_data(){
+      const char *data= "Callback function called";
+      const char *sql= "SELECT * from MoveSet";
+      rc= sqlite3_exec(db, sql, 0, (void*)data, &zErrMsg);
+      if (rc!= SQLITE_OK ){
+         fprintf(stderr, "SQL error: %s\n", zErrMsg);
+         sqlite3_free(zErrMsg);
+      }else 
+         fprintf(stdout, "Operation done  sucessfully\n");
+         return 0;
+    }
+
+    bool get_database_value(const node_t& board, score_t& zlo, score_t& zhi){
+      bool gotten = false;
+      const char *sql;
+      std::ostringstream current, out;
+      print_board(board, current, true);
+      std::string curr = current.str();
+      out<< "SELECT LO, HI FROM MoveSet WHERE \"BOARD\"=\""<<curr<<"\" AND \"PLY\"="<<board.depth<<";";
+      std::string result = out.str();
+      sql=result.c_str();
+      int nrow, ncolumn;
+      char ** azResult=NULL;//index:5=ply,6=board, 7=hi, 8=lo
+      rc= sqlite3_get_table(db, sql, &azResult, &nrow, &ncolumn, &zErrMsg);
+      if(nrow > 0) {
+        for (int i=0; i<(nrow+1)*ncolumn;i++)
+          cout<<"azResult["<<i<<"] ="<<azResult[i]<<"\n";
+        cout << "nrow=" << nrow << " ncol=" << ncolumn << endl;
+        stringstream strValue; /*
+                                  strValue <<*azResult[5]; 
+        //std::string s= *azResult[5];
+        int num;//= atoi(s.c_str());
+        strValue>>num;
+        if (num == board.depth)*/
+        zlo = atoi(azResult[ncolumn+0]);
+        zhi = atoi(azResult[ncolumn+1]);
+        cout << "zlo=" << zlo << " zhi=" << zhi << endl;
+        gotten=true;
+      }
+      sqlite3_free_table(azResult);
+      return gotten;
+    }
+
+      int search_board(const node_t& board,std::ostringstream& out, const char *select, const char *value, std::string& search){
+        const char *sql;
+        char *data= (char *)calloc(1, sizeof (*data));
+        out<< "SELECT "<<select<<" FROM MoveSet WHERE \""<<value<<"\"=\""<<search<<"\";";
+        std::string result = out.str();
+        sql = result.c_str();
+        rc = sqlite3_exec(db,sql,callback, (void*)data,&zErrMsg);
+        cout<<data<<"/n";
+        //cout<<"This is callback"<< callback << "\n";
+        if (rc!= SQLITE_OK){
+          fprintf(stderr, "SQL error: %s\n", zErrMsg);
+          sqlite3_free(zErrMsg);
+        }else
+          //fprintf(stdout, "Looked through board successfully\n");
+          return rc;
+
+
+      }
+
+      bool get_transposition_value(const node_t& board, score_t& lower, score_t& upper){
+        bool gotten = false;
+        std::ostringstream current;
+        print_board(board,current,true);
+        std::string curr = current.str();
+        const char *hash = "HASH, HI";
+        const char *b = "BOARD";
+        std::ostringstream search;
+        search_board(board,search,  hash, b, curr);
+        std::string buscar = search.str();
+        //cout<< "Value "<< buscar<<"\n";
+        //fprintf(stdout, "Value: %s", search);
+        /*if (z->depth >= 0 && board_equals(board, z->board)){
+          lower = z->lower;
+          upper = z->upper;
+          gotten = true
+          } else {
+          lower = bad_min_score;
+          upper = bad_max_score;
+          }*/
+        return gotten;
+      }
+
+      //callback used for select operation
+      static int callback(void *NotUsed, int argc, char **argv, char **azColName){
+        int i;
+        std::ostringstream out;
+        char ** res = (char **) NotUsed;
+        //*res=NULL(sizeof(char *));
+        // cout<<res<<"test\n";
+        *res =(char *)calloc(strlen(argv[2]),sizeof(char *));
+        strcpy(*res, argv[2]);
+        return 0;
+        for(i=0; i<argc; i++){
+          out<< argv[i]<<"\n";
+          // printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
+        }
+        printf("\n");
+        return 0;
+      };
+      int main(){
+        return 0;
+      }
+
+    };
+//extern database dbase;
+#endif

headers/main.hpp

@@ -1,4 +1,4 @@
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 //  Copyright (c) 2011 Steve Brandt and Phillip LeBlanc
 //
 //  Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -19,13 +19,14 @@
 int main(int argc, char *argv[]);
 int parse_move(std::vector<chess_move>& workq, const char *s);
 char *move_str(chess_move& m);
-void print_board(const node_t& board, std::ostream& out);
+void print_board(const node_t& board, std::ostream& out,bool trimmed=false);
 int print_result(std::vector<chess_move>& workq, node_t& board);
 void start_benchmark(std::string filename, int ply_level, int num_runs,bool parallel);
 int get_ms();
 std::string get_log_name();
 int chx_main();
 #ifdef HPX_SUPPORT
+extern database dbase;
 extern std::ofstream **streams;
 extern bool file_output_enabled;
 #endif