26277292931

Committed 22 May 2026 08:31AM UTC coverage: 86.567% (-1.5%) from 88.114%

Build # 26277292931

Build Type

Pull #252

github

Committed by

web-flow

Commit Message

Merge 6e1a321b4 into 0a94b5ba4

Pull Request Pull Request #252: Allow schema changes in diffs

Coverage Stats

926 of 1098 new or added lines in 13 files covered. (84.34%)

13 existing lines in 3 files now uncovered.

4150 of 4794 relevant lines covered (86.57%)

607.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.29

/geodiff/src/changesetreader.cpp

/*
 GEODIFF - MIT License
 Copyright (C) 2020 Martin Dobias
*/

#include "changesetreader.h"

#include "changeset.h"
#include "geodiffutils.hpp"
#include "changesetgetvarint.h"
#include "portableendian.h"
#include "sqliteutils.h"
#include "tableschema.h"

#include <assert.h>
#include <memory.h>

#include <sstream>


ChangesetReader::ChangesetReader() = default;

ChangesetReader::~ChangesetReader() = default;


bool ChangesetReader::open( const std::string &filename )
{
  try
  {
    mBuffer.reset( new Buffer );
    mBuffer->read( filename );
  }
  catch ( const GeoDiffException & )
  {
    return false;
  }

  return true;
}

bool ChangesetReader::nextEntry( ChangesetEntry &entry )
{
  while ( 1 )
  {
    if ( mOffset >= mBuffer->size() )
      break;   // EOF

    ChangesetEntryType type = static_cast<ChangesetEntryType>( readByte() );
    if ( type == ChangesetEntryType::OpTableRecord )
    {
      readTableRecord();
      // and now continue reading, we want an entry
    }
    else if ( type == ChangesetEntryType::OpInsert || type == ChangesetEntryType::OpUpdate || type == ChangesetEntryType::OpDelete )
    {
      entry = readDataEntry( type );
      return true;  // we're done!
    }
    else if ( type == ChangesetEntryType::OpCreateTable )
    {
      entry = readCreateTableEntry();
      return true;
    }
    else if ( type == ChangesetEntryType::OpDropTable )
    {
      entry = readDropTableEntry();
      return true;
    }
    else if ( type == ChangesetEntryType::OpAddColumn )
    {
      entry = readAddColumnEntry();
      return true;
    }
    else if ( type == ChangesetEntryType::OpDropColumn )
    {
      entry = readDropColumnEntry();
      return true;
    }
    else
    {
      throwReaderError( "Unknown entry type " + std::to_string( static_cast<int>( type ) ) );
    }
  }
  return false;
}

bool ChangesetReader::isEmpty() const
{
  return mBuffer->size() == 0;
}

void ChangesetReader::rewind()
{
  mOffset = 0;
  mCurrentTable = {};
}

char ChangesetReader::readByte()
{
  if ( mOffset >= mBuffer->size() )
    throwReaderError( "readByte: at the end of buffer" );
  const char *ptr = mBuffer->c_buf() + mOffset;
  ++mOffset;
  return *ptr;
}

int ChangesetReader::readVarint()
{
  u32 value;
  const unsigned char *ptr = reinterpret_cast<const unsigned char *>( mBuffer->c_buf() ) + mOffset;
  int nBytes = getVarint32( ptr, value );
  mOffset += nBytes;
  return value;
}

std::string ChangesetReader::readNullTerminatedString()
{
  const char *ptr = mBuffer->c_buf() + mOffset;
  int count = 0;
  while ( mOffset + count < mBuffer->size() && ptr[count] )
    ++count;

  if ( mOffset + count >= mBuffer->size() )
    throwReaderError( "readNullTerminatedString: at the end of buffer" );

  mOffset += count + 1;
  return std::string( ptr, count );
}

void ChangesetReader::readRowValues( std::vector<Value> &values )
{
  // let's ensure we have the right size of array
  if ( values.size() != mCurrentTable->columnCount() )
  {
    values.resize( mCurrentTable->columnCount() );
  }

  for ( size_t i = 0; i < mCurrentTable->columnCount(); ++i )
  {
    int type = readByte();
    if ( type == Value::TypeInt ) // 0x01
    {
      // 64-bit int (big endian)
      int64_t v;
      uint64_t x;
      memcpy( &x, mBuffer->c_buf() + mOffset, 8 );
      mOffset += 8;
      x = be64toh( x ); // convert big endian to host
      memcpy( &v, &x, 8 );
      values[i].setInt( v );
    }
    else if ( type == Value::TypeDouble ) // 0x02
    {
      // 64-bit double (big endian)
      double v;
      uint64_t x;
      memcpy( &x, mBuffer->c_buf() + mOffset, 8 );
      mOffset += 8;
      x = be64toh( x ); // convert big endian to host
      memcpy( &v, &x, 8 );
      values[i].setDouble( v );
    }
    else if ( type == Value::TypeText || type == Value::TypeBlob ) // 0x03 or 0x04
    {
      int len = readVarint();
      if ( mOffset + len > mBuffer->size() )
        throwReaderError( "readRowValues: text/blob: at the end of buffer" );
      values[i].setString( type == Value::TypeText ? Value::TypeText : Value::TypeBlob, mBuffer->c_buf() + mOffset, len );
      mOffset += len;
    }
    else if ( type == Value::TypeNull ) // 0x05
    {
      values[i].setNull();
    }
    else if ( type == Value::TypeUndefined )  // undefined value  (different from NULL)
    {
      values[i].setUndefined();
    }
    else
    {
      throwReaderError( "readRowValues: unexpected entry type" );
    }
  }
}

void ChangesetReader::readTableRecord()
{
  /* A 'table' record consists of:
  **
  **   * A constant 'T' character,
  **   * Number of columns in said table (a varint),
  **   * An array of nCol bytes (sPK),
  **   * A nul-terminated table name.
  */

  int nCol = readVarint();
  if ( nCol < 0 || nCol > 65536 )
    throwReaderError( "readByte: unexpected number of columns" );

  mCurrentTable = std::make_shared<ChangesetTable>();
  mCurrentTable->primaryKeys.clear();

  for ( int i = 0; i < nCol; ++i )
  {
    mCurrentTable->primaryKeys.push_back( readByte() );
  }

  mCurrentTable->name = readNullTerminatedString();
}

ChangesetDataEntry ChangesetReader::readDataEntry( ChangesetEntryType type )
{
  ChangesetDataEntry entry;
  readByte();
  if ( type != ChangesetEntryType::OpInsert )
    readRowValues( entry.oldValues );
  else
    entry.oldValues.erase( entry.oldValues.begin(), entry.oldValues.end() );
  if ( type != ChangesetEntryType::OpDelete )
    readRowValues( entry.newValues );
  else
    entry.newValues.erase( entry.newValues.begin(), entry.newValues.end() );

  entry.op = static_cast<ChangesetDataEntry::OperationType>( type );
  entry.table = mCurrentTable;
  return entry;
}

TableColumnInfo ChangesetReader::readColumnInfo()
{
  TableColumnInfo column;
  column.name = readNullTerminatedString();
  column.type.baseType = static_cast<TableColumnType::BaseType>( readByte() );
  column.type.dbType = column.type.baseTypeToString( column.type.baseType );
  char flags = readByte();
  column.isPrimaryKey = flags & 1;
  column.isNotNull = flags & ( 1 << 1 );
  column.isAutoIncrement = flags & ( 1 << 2 );
  column.isGeometry = flags & ( 1 << 3 );
  column.geomHasZ = flags & ( 1 << 4 );
  column.geomHasM = flags & ( 1 << 5 );
  column.geomType = readNullTerminatedString();
  column.geomSrsId = readVarint();
  return column;
}

ChangesetCreateTableEntry ChangesetReader::readCreateTableEntry()
{
  ChangesetCreateTableEntry entry;
  entry.tableName = readNullTerminatedString();
  int columnCount = readVarint();
  entry.columns.resize( columnCount );
  for ( size_t i = 0; i < entry.columns.size(); i++ )
  {
    entry.columns[i] = readColumnInfo();
  }
  return entry;
}

ChangesetDropTableEntry ChangesetReader::readDropTableEntry()
{
  ChangesetDropTableEntry entry;
  entry.tableName = readNullTerminatedString();
  int columnCount = readVarint();
  entry.columns.resize( columnCount );
  for ( size_t i = 0; i < entry.columns.size(); i++ )
  {
    entry.columns[i] = readColumnInfo();
  }
  return entry;
}

ChangesetAddColumnEntry ChangesetReader::readAddColumnEntry()
{
  ChangesetAddColumnEntry entry;
  entry.tableName = readNullTerminatedString();
  entry.column = readColumnInfo();
  return entry;
}

ChangesetDropColumnEntry ChangesetReader::readDropColumnEntry()
{
  ChangesetDropColumnEntry entry;
  entry.tableName = readNullTerminatedString();
  entry.column = readColumnInfo();
  return entry;
}

void ChangesetReader::throwReaderError( const std::string &message ) const
{
  std::ostringstream stringStream;
  stringStream << "Reader error at offset " << mOffset << ":\n" << message;
  std::string str = stringStream.str();
  throw GeoDiffException( str );
}

1	/*
2	GEODIFF - MIT License
3	Copyright (C) 2020 Martin Dobias
4	*/
5
6	#include "changesetreader.h"
7
8	#include "changeset.h"
9	#include "geodiffutils.hpp"
10	#include "changesetgetvarint.h"
11	#include "portableendian.h"
12	#include "sqliteutils.h"
13	#include "tableschema.h"
14
15	#include <assert.h>
16	#include <memory.h>
17
18	#include <sstream>
19
20
21	ChangesetReader::ChangesetReader() = default;	879✔
22
23	ChangesetReader::~ChangesetReader() = default;	879✔
24
25
26	bool ChangesetReader::open( const std::string &filename )	880✔
27	{
28	try
29	{
30	mBuffer.reset( new Buffer );	880✔
31	mBuffer->read( filename );	880✔
32	}
33	catch ( const GeoDiffException & )	10✔
34	{
35	return false;	10✔
36	}	10✔
37
38	return true;	870✔
39	}
40
41	bool ChangesetReader::nextEntry( ChangesetEntry &entry )	2,416✔
42	{
43	while ( 1 )
44	{
45	if ( mOffset >= mBuffer->size() )	3,318✔
46	break; // EOF	748✔
47
48	ChangesetEntryType type = static_cast<ChangesetEntryType>( readByte() );	2,570✔
49	if ( type == ChangesetEntryType::OpTableRecord )	2,570✔
50	{
51	readTableRecord();	902✔
52	// and now continue reading, we want an entry
53	}
54	else if ( type == ChangesetEntryType::OpInsert \|\| type == ChangesetEntryType::OpUpdate \|\| type == ChangesetEntryType::OpDelete )	1,668✔
55	{
56	entry = readDataEntry( type );	1,638✔
57	return true; // we're done!	1,638✔
58	}
59	else if ( type == ChangesetEntryType::OpCreateTable )	30✔
60	{
61	entry = readCreateTableEntry();	7✔
62	return true;	7✔
63	}
64	else if ( type == ChangesetEntryType::OpDropTable )	23✔
65	{
66	entry = readDropTableEntry();	7✔
67	return true;	7✔
68	}
69	else if ( type == ChangesetEntryType::OpAddColumn )	16✔
70	{
71	entry = readAddColumnEntry();	7✔
72	return true;	7✔
73	}
74	else if ( type == ChangesetEntryType::OpDropColumn )	9✔
75	{
76	entry = readDropColumnEntry();	7✔
77	return true;	7✔
78	}
79	else
80	{
81	throwReaderError( "Unknown entry type " + std::to_string( static_cast<int>( type ) ) );	6✔
82	}
83	}	902✔
84	return false;	748✔
85	}
86
87	bool ChangesetReader::isEmpty() const	389✔
88	{
89	return mBuffer->size() == 0;	389✔
90	}
91
92	void ChangesetReader::rewind()	62✔
93	{
94	mOffset = 0;	62✔
95	mCurrentTable = {};	62✔
96	}	62✔
97
98	char ChangesetReader::readByte()	15,025✔
99	{
100	if ( mOffset >= mBuffer->size() )	15,025✔
101	throwReaderError( "readByte: at the end of buffer" );	×
102	const char *ptr = mBuffer->c_buf() + mOffset;	15,025✔
103	++mOffset;	15,025✔
104	return *ptr;	15,025✔
105	}
106
107	int ChangesetReader::readVarint()	3,589✔
108	{
109	u32 value;
110	const unsigned char ptr = reinterpret_cast<const unsigned char >( mBuffer->c_buf() ) + mOffset;	3,589✔
111	int nBytes = getVarint32( ptr, value );	3,589✔
112	mOffset += nBytes;	3,589✔
113	return value;	3,589✔
114	}
115
116	std::string ChangesetReader::readNullTerminatedString()	1,042✔
117	{
118	const char *ptr = mBuffer->c_buf() + mOffset;	1,042✔
119	int count = 0;	1,042✔
120	while ( mOffset + count < mBuffer->size() && ptr[count] )	7,573✔
121	++count;	6,531✔
122
123	if ( mOffset + count >= mBuffer->size() )	1,042✔
124	throwReaderError( "readNullTerminatedString: at the end of buffer" );	×
125
126	mOffset += count + 1;	1,042✔
127	return std::string( ptr, count );	2,084✔
128	}
129
130	void ChangesetReader::readRowValues( std::vector<Value> &values )	2,026✔
131	{
132	// let's ensure we have the right size of array
133	if ( values.size() != mCurrentTable->columnCount() )	2,026✔
134	{
135	values.resize( mCurrentTable->columnCount() );	2,026✔
136	}
137
138	for ( size_t i = 0; i < mCurrentTable->columnCount(); ++i )	9,462✔
139	{
140	int type = readByte();	7,436✔
141	if ( type == Value::TypeInt ) // 0x01	7,436✔
142	{
143	// 64-bit int (big endian)
144	int64_t v;
145	uint64_t x;
146	memcpy( &x, mBuffer->c_buf() + mOffset, 8 );	2,703✔
147	mOffset += 8;	2,703✔
148	x = be64toh( x ); // convert big endian to host	2,703✔
149	memcpy( &v, &x, 8 );	2,703✔
150	values[i].setInt( v );	2,703✔
151	}
152	else if ( type == Value::TypeDouble ) // 0x02	4,733✔
153	{
154	// 64-bit double (big endian)
155	double v;
156	uint64_t x;
157	memcpy( &x, mBuffer->c_buf() + mOffset, 8 );	61✔
158	mOffset += 8;	61✔
159	x = be64toh( x ); // convert big endian to host	61✔
160	memcpy( &v, &x, 8 );	61✔
161	values[i].setDouble( v );	61✔
162	}
163	else if ( type == Value::TypeText \|\| type == Value::TypeBlob ) // 0x03 or 0x04	4,672✔
164	{
165	int len = readVarint();	2,617✔
166	if ( mOffset + len > mBuffer->size() )	2,617✔
167	throwReaderError( "readRowValues: text/blob: at the end of buffer" );	×
168	values[i].setString( type == Value::TypeText ? Value::TypeText : Value::TypeBlob, mBuffer->c_buf() + mOffset, len );	2,617✔
169	mOffset += len;	2,617✔
170	}	2,617✔
171	else if ( type == Value::TypeNull ) // 0x05	2,055✔
172	{
173	values[i].setNull();	505✔
174	}
175	else if ( type == Value::TypeUndefined ) // undefined value (different from NULL)	1,550✔
176	{
177	values[i].setUndefined();	1,550✔
178	}
179	else
180	{
181	throwReaderError( "readRowValues: unexpected entry type" );	×
182	}
183	}
184	}	2,026✔
185
186	void ChangesetReader::readTableRecord()	902✔
187	{
188	/* A 'table' record consists of:
189	**
190	** * A constant 'T' character,
191	** * Number of columns in said table (a varint),
192	** * An array of nCol bytes (sPK),
193	** * A nul-terminated table name.
194	*/
195
196	int nCol = readVarint();	902✔
197	if ( nCol < 0 \|\| nCol > 65536 )	902✔
198	throwReaderError( "readByte: unexpected number of columns" );	×
199
200	mCurrentTable = std::make_shared<ChangesetTable>();	902✔
201	mCurrentTable->primaryKeys.clear();	902✔
202
203	for ( int i = 0; i < nCol; ++i )	4,171✔
204	{
205	mCurrentTable->primaryKeys.push_back( readByte() );	3,269✔
206	}
207
208	mCurrentTable->name = readNullTerminatedString();	902✔
209	}	902✔
210
211	ChangesetDataEntry ChangesetReader::readDataEntry( ChangesetEntryType type )	1,638✔
212	{
213	ChangesetDataEntry entry;	1,638✔
214	readByte();	1,638✔
215	if ( type != ChangesetEntryType::OpInsert )	1,638✔
216	readRowValues( entry.oldValues );	654✔
217	else
218	entry.oldValues.erase( entry.oldValues.begin(), entry.oldValues.end() );	984✔
219	if ( type != ChangesetEntryType::OpDelete )	1,638✔
220	readRowValues( entry.newValues );	1,372✔
221	else
222	entry.newValues.erase( entry.newValues.begin(), entry.newValues.end() );	266✔
223
224	entry.op = static_cast<ChangesetDataEntry::OperationType>( type );	1,638✔
225	entry.table = mCurrentTable;	1,638✔
226	return entry;	1,638✔
NEW 227	}	×
228
229	TableColumnInfo ChangesetReader::readColumnInfo()	56✔
230	{
231	TableColumnInfo column;	56✔
232	column.name = readNullTerminatedString();	56✔
233	column.type.baseType = static_cast<TableColumnType::BaseType>( readByte() );	56✔
234	column.type.dbType = column.type.baseTypeToString( column.type.baseType );	56✔
235	char flags = readByte();	56✔
236	column.isPrimaryKey = flags & 1;	56✔
237	column.isNotNull = flags & ( 1 << 1 );	56✔
238	column.isAutoIncrement = flags & ( 1 << 2 );	56✔
239	column.isGeometry = flags & ( 1 << 3 );	56✔
240	column.geomHasZ = flags & ( 1 << 4 );	56✔
241	column.geomHasM = flags & ( 1 << 5 );	56✔
242	column.geomType = readNullTerminatedString();	56✔
243	column.geomSrsId = readVarint();	56✔
244	return column;	56✔
UNCOV 245	}	×
246
247	ChangesetCreateTableEntry ChangesetReader::readCreateTableEntry()	7✔
248	{
249	ChangesetCreateTableEntry entry;	7✔
250	entry.tableName = readNullTerminatedString();	7✔
251	int columnCount = readVarint();	7✔
252	entry.columns.resize( columnCount );	7✔
253	for ( size_t i = 0; i < entry.columns.size(); i++ )	28✔
254	{
255	entry.columns[i] = readColumnInfo();	21✔
256	}
257	return entry;	7✔
NEW 258	}	×
259
260	ChangesetDropTableEntry ChangesetReader::readDropTableEntry()	7✔
261	{
262	ChangesetDropTableEntry entry;	7✔
263	entry.tableName = readNullTerminatedString();	7✔
264	int columnCount = readVarint();	7✔
265	entry.columns.resize( columnCount );	7✔
266	for ( size_t i = 0; i < entry.columns.size(); i++ )	28✔
267	{
268	entry.columns[i] = readColumnInfo();	21✔
269	}
270	return entry;	7✔
NEW 271	}	×
272
273	ChangesetAddColumnEntry ChangesetReader::readAddColumnEntry()	7✔
274	{
275	ChangesetAddColumnEntry entry;	7✔
276	entry.tableName = readNullTerminatedString();	7✔
277	entry.column = readColumnInfo();	7✔
278	return entry;	7✔
NEW 279	}	×
280
281	ChangesetDropColumnEntry ChangesetReader::readDropColumnEntry()	7✔
282	{
283	ChangesetDropColumnEntry entry;	7✔
284	entry.tableName = readNullTerminatedString();	7✔
285	entry.column = readColumnInfo();	7✔
286	return entry;	7✔
NEW 287	}	×
288
289	void ChangesetReader::throwReaderError( const std::string &message ) const	2✔
290	{
291	std::ostringstream stringStream;	2✔
292	stringStream << "Reader error at offset " << mOffset << ":\n" << message;	2✔
293	std::string str = stringStream.str();	2✔
294	throw GeoDiffException( str );	2✔
295	}	4✔

MerginMaps / geodiff / 26277292931

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous