compteurelec/server/db_access.c

#include "db_access.h"
#include "db.h"
#define N_ANNEES 4
#define N_MONTH 12
#define N_DAYS 31
#define N_BY_DAYS (3600*24)



int  _db_index_load(db_metadata_t** out, off_t *n,  const char* path)
{
	int f = open(path, O_RDONLY );
	if(f<0)
	{
		fprintf(stderr, "Error reading '%s' (_db_index_load())", path);
		perror(" ");
		*out=NULL;
		return errno;
	}
	*n=lseek(f, 0, SEEK_END)/sizeof(db_metadata_t);
	*out=malloc(sizeof(db_metadata_t)* (*n));
	if(!*out)
	{
		fprintf(stderr, "Error allocating %ld bytes (_db_index_load())", sizeof(db_metadata_t)*(*n));
		perror(" ");
		return errno;
	}
	lseek(f,0,SEEK_SET);
	read(f, *out, sizeof(db_metadata_t)* (*n));
	close(f);
	
	return 0;	
}

int  db_index_load(db_index_t* out)
{
	int fd;
	if(!out) return -1;
	if(_db_index_load(&out->days, &out->ndays, "metadata_days")) 		return errno;
	if(_db_index_load(&out->monthes, &out->nmonthes, "metadata_monthes")) return errno;
	if(_db_index_load(&out->years, &out->nyears, "metadata_years")) return errno;
	fd = open("data",  O_RDONLY);
	if(fd<0)
	{
		fprintf(stderr, "Unable to open data file (db_index_load())");
		perror(" ");
		return -1;
	}
	out->data_count=lseek(fd, 0, SEEK_END)/sizeof(db_data_t);
	close(fd);	
	return 0;
}

void db_index_release(db_index_t* in)
{
	if(!in) return;
	if(in->days) free(in->days);
	if(in->monthes) free(in->monthes);
	if(in->years) free(in->years);
}

db_data_interval_t* db_data_interval_new(uint32_t start, uint32_t len)
{
	db_data_interval_t* ret;
	ret=malloc(sizeof(db_data_interval_t));
	if(!ret)
	{
		fprintf(stderr, "Unable to allocate %ld bytes (db_data_interval_new())", 
					sizeof(db_data_interval_t));
		perror(" ");
		return NULL;
	}
	
	ret->start=start;
	ret->len=len;
	ret->data=malloc((ret->len)*sizeof(db_data_t));
	if(!ret->data)
	{
		fprintf(stderr, "Unable to allocate %ld bytes (db_data_interval_new())", 
					(ret->len)*sizeof(db_data_t));
		perror(" ");
		free(ret);
		return NULL;
	}
	
	return ret;
}

void 								db_data_interval_free(db_data_interval_t* dbdi)
{
	if(!dbdi) return;
	if(dbdi->data) free(dbdi->data);
	free(dbdi);
}


uint32_t db_index_get(db_t* db, db_date_t d, uint32_t time, int f)
{
	db_interval_t inter;
	db_data_t *buffer=NULL;
	off_t size;
	int i,n;
	
	inter = db_inter_get(db, d);
	if(inter.start==0xFFFFFFFF || inter.len==0xFFFFFFFF) return 0xFFFFFFFF;
	n=inter.len;
	
	buffer = malloc(inter.len*sizeof(db_data_t));
	if(!buffer)
	{
		fprintf(stderr, "Unable to allocate %ld bytes (db_index_get())", inter.len*sizeof(db_data_t));
		perror(" ");
		return 0xffffffff;
	}
	lseek(f, inter.start*sizeof(db_data_t), SEEK_SET);
	size=read(f, buffer, sizeof(db_data_t) * inter.len);
	if(size<inter.len*sizeof(db_data_t))
	{
		fprintf(stderr, "Unable to read entire %ld / %ld bytes (db_index_get())", size, inter.len*sizeof(db_data_t));
		perror(" ");
		return 0xffffffff;
	}
	
	for(i=0; i<n; i++)
		if(buffer[i].micros>time) break;
		
	free(buffer);
	i--;
	if(inter.start==0) return 0;
	return inter.start+i;
}


int db_load_page(db_t* db, uint64_t page, db_data_t* buffer)
{
	int fd = open("data", O_RDONLY), r;
	if(fd<0)
	{
		fprintf(stderr, "Error unable to load page %ld (%x->%x) (db_load_page())",
										page, page*db->cache->page_size*sizeof(db_data_t), 
										(page+1)*db->cache->page_size*sizeof(db_data_t));
		perror(" ");
		return -1;
	}
	lseek(fd,page*db->cache->page_size*sizeof(db_data_t), SEEK_SET);
	r=read(fd, buffer,  db->cache->page_size*sizeof(db_data_t));
	close(fd);
	return r;
}


void write_data()
{
	int f = open("data", O_RDWR | O_CREAT, 0777);
	int i;
	db_data_t data;
	data.date.day=1;
	data.date.month=1;
	data.date.year=2016;
	data.micros=0;
	
	for(i=0; i<N_ANNEES*N_MONTH*N_DAYS*N_BY_DAYS; i++)
	{
		if(data.micros>=N_BY_DAYS*1000)
		{
			data.date.day++;
			data.micros=0;
			if(data.date.day>N_DAYS)
			{
				data.date.day=1;
				data.date.month++;
				if(data.date.month>N_MONTH)
				{
					data.date.month=1;
					data.date.year++;
				}
			}
		}
		write(f, &data, sizeof(db_data_t));
		
		data.micros+=1000;
		//fprintf(f, "%d %d %d : %ld\n", data.date.year, data.date.month, data.date.day, data.micros);
	}
	
	close(f);
}


void write_day()
{
	int f = open("metadata_days", O_RDWR | O_CREAT, 0777 );
	off_t i;
	db_metadata_t data;
	data.date.day=0;
	data.date.month=1;
	data.date.year=2016;
	data.index=0;
	
	for(i=0; i<N_ANNEES*N_MONTH*N_DAYS; i++)
	{
		data.index=i*N_BY_DAYS;
		//data.index=i;
		data.date.day++;
		if(data.date.day>N_DAYS)
		{
			data.date.day=1;
			data.date.month++;
			if(data.date.month>N_MONTH)
			{
				data.date.month=1;
				data.date.year++;
			}
		}
		write(f, &data, sizeof(db_metadata_t));
	}
	
	close(f);
}

void write_month()
{
	int f = open("metadata_monthes", O_RDWR | O_CREAT, 0777 );
	int i;
	db_metadata_t data;
	data.date.day=1;
	data.date.month=0;
	data.date.year=2016;
	data.index=0;
	
	for(i=0; i<N_MONTH*N_ANNEES; i++)
	{
		data.index=i*N_DAYS;
		
		data.date.month++;
		if(data.date.month>N_MONTH)
		{
			data.date.month=1;
			data.date.year++;
		}
		write(f, &data, sizeof(db_metadata_t));
	}
	
	close(f);
}


void write_year()
{
	int f = open("metadata_years", O_RDWR | O_CREAT, 0777 );
	int i;
	db_metadata_t data;
	data.date.day=1;
	data.date.month=1;
	data.date.year=2016-1;
	data.index=0;
	
	for(i=0; i<N_ANNEES; i++)
	{
		data.index=i*N_MONTH;
		data.date.year++;
		
		write(f, &data, sizeof(db_metadata_t));
	}
	
	close(f);
}



db_data_interval_t* db_data_load(db_t* db, db_date_t ds, uint32_t dsm,
																							db_date_t de, uint32_t dem)
{
	int f;
	db_data_interval_t *inter=NULL;
	uint32_t start, len;
	off_t size;
	
	f=open("data", O_RDONLY | O_LARGEFILE);
	if(f<0)
	{
		fprintf(stderr, "Unable to open 'data' (db_data_load())");
		perror(" ");
		return NULL;
	}
	start=db_index_get(db, ds, dsm, f);
	len=db_index_get(db, de, dem, f)-start+1;
	
	if(start==0xffffffff || len==0xffffffff)
	{
		close(f);
		return NULL;
	}
	
	inter=db_data_interval_new(start, len);
	lseek(f, start*sizeof(db_data_t), SEEK_SET);
	size=read(f, inter->data, sizeof(db_data_t)*(len));
	if(size<(len)*sizeof(db_data_t))
	{
		fprintf(stderr, "Unable to read entire %ld / %ld bytes (db_data_load())",
							size, (len)*sizeof(db_data_t));
		perror(" ");
		return inter;
	}
	close(f);
	return inter;
}



int main(int argc, char** argv)
{
/*	write_data();
	write_day();
	write_month();
	write_year();*/
	db_t db;
	db_data_interval_t *di;
	db_date_t ds, de;
	int i;
	uint32_t dsm=9999;
	ds.year=2019; ds.month=12; ds.day=31;
	de.year=2016; de.month=12; de.day=7;
	db_init(&db);
	//di=db_data_load(&db, ds, dsm, de, dsm+100000000);
	
	di=db_data_load(&db, ds, dsm, ds, dsm);
	for(i=0; i<di->len; i++)
	{
		printf("%ld : (%.2ld-%.2ld-%.4ld) -> %ld\n", di->start+i
																				, di->data[i].date.day
																				, di->data[i].date.month
																				, di->data[i].date.year
																				, di->data[i].micros);
	}
	free(di->data);

	
	
	int a,m,j,ms;
	/*for(a=2015; a<2021; a++)
	{
		printf("year: %d\n", a);
		ds.year=a;
		de.year=a;
		for(m=1; m<13; m++)
		{
			printf("\tmonth: %d\n", m);
			ds.month=m;
			de.month=m;
			for(j=1; j<31; j++)
			{
				printf("\t\tday: %d\n", j);
				ds.day=j;
				de.day=j+1;
				
				for(ms=0; ms<24*3600*1000; ms+=60*1000)
				{
					di=db_data_load(&db, ds, dsm, ds, dsm);
					if(!di)
					{
						fprintf(stderr , "Error on (%.2d-%.2d-%.2d : %d)\n", j, m ,a ,ms/1000);
					}
					else free(di->data);
				}
				di=db_data_load(&db, ds, dsm, ds, dsm);
				int l;
				
				
				di=db_data_load(&db, ds, dsm, de, dsm);
				if(!di)
				{
					fprintf(stderr , "Error on (%.2d-%.2d-%.2d : %d)\n", j, m ,a ,ms/1000);
				}
				else free(di->data);
				
			}
		}
	}*/
	ds.year=2016;
	de.year=ds.year;
	ds.month=5;
	de.month=ds.month;
	ds.day=15;
	de.day=ds.day+1;
	dsm=1000*3600*24;
	int l;
	di=db_data_load(&db, ds, 3600*24*100, de, 1);
	for(l=0; l<di->len; l++)
					printf("\t\t%d-%d-%d %d:%d:%d.%d\n", di->data[l].date.day, di->data[l].date.month, di->data[l].date.year,
																								di->data[l].micros/3600000, (di->data[l].micros%3600000)/60000, di->data[l].micros%60000/1000, di->data[l].micros%1000);
	db_free(&db);
	
	return 0;
}