llvm::Value* Load::Codegen(WasmFunction* fct, llvm::IRBuilder<>& builder) { llvm::Value* address = GetPointer(fct, builder); // Create the load. llvm::Value* value = builder.CreateLoad(address, "load"); // Now we need to convert this load to a size potentially. switch (type_) { case INT_32: case INT_64: value = ResizeIntegerIfNeed(value, value->getType(), type_, sign_, builder); break; case FLOAT_32: case FLOAT_64: assert(GetTypeSize(type_) == size_); break; default: assert(0); break; } return value; }
int GetSafeNB(char pre, int MaxL1) { int i, L1, tsize, inc; tsize = GetTypeSize(pre); inc = ATL_MinMMAlign / tsize; if (inc < 4) inc = 4; L1 = (GetCacheSize(MaxL1) * 1024) / tsize; for (i=inc; i*i < L1; i += inc); if (i*i > L1) i -= inc; if (pre == 'd' || pre == 's') { if (i*i == L1) i -= inc; } else { if (i*i == L1) i -= 2*inc; else i -= inc; } if (i < 16) i = 16; if (i > 80) i = 80; return(i); }
TEST_F(DropTests, DroppingTable) { catalog::Bootstrapper::bootstrap(); auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); txn_manager.BeginTransaction(); // Insert a table first auto id_column = catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "dept_id", true); auto name_column = catalog::Column(VALUE_TYPE_VARCHAR, 32, "dept_name", false); std::unique_ptr<catalog::Schema> table_schema(new catalog::Schema({id_column, name_column})); std::unique_ptr<catalog::Schema> table_schema2(new catalog::Schema({id_column, name_column})); catalog::Bootstrapper::global_catalog->CreateDatabase("default_database"); txn_manager.CommitTransaction(); txn_manager.BeginTransaction(); catalog::Bootstrapper::global_catalog->CreateTable("default_database", "department_table", std::move(table_schema)); txn_manager.CommitTransaction(); txn_manager.BeginTransaction(); catalog::Bootstrapper::global_catalog->CreateTable("default_database", "department_table_2", std::move(table_schema2)); txn_manager.CommitTransaction(); EXPECT_EQ(catalog::Bootstrapper::global_catalog->GetDatabaseWithName("default_database")->GetTableCount(), 2); // Now dropping the table using the executer txn_manager.BeginTransaction(); catalog::Bootstrapper::global_catalog->DropTable("default_database", "department_table"); txn_manager.CommitTransaction(); EXPECT_EQ(catalog::Bootstrapper::global_catalog->GetDatabaseWithName("default_database")->GetTableCount(), 1); }
PSZ ARRAY::MakeArrayList(PGLOBAL g) { char *p, *tp; int i; size_t z, len = 2; if (Type == TYPE_LIST) return "(?" "?" "?)"; // To be implemented z = MY_MAX(24, GetTypeSize(Type, Len) + 4); tp = (char*)PlugSubAlloc(g, NULL, z); for (i = 0; i < Nval; i++) { Value->SetValue_pvblk(Vblp, i); Value->Print(g, tp, z); len += strlen(tp); } // enfor i if (trace) htrc("Arraylist: len=%d\n", len); p = (char *)PlugSubAlloc(g, NULL, len); strcpy(p, "("); for (i = 0; i < Nval;) { Value->SetValue_pvblk(Vblp, i); Value->Print(g, tp, z); strcat(p, tp); strcat(p, (++i == Nval) ? ")" : ","); } // enfor i if (trace) htrc("Arraylist: newlen=%d\n", strlen(p)); return p; } // end of MakeArrayList
void VertexData::Load(u32 start, u32 count) { const u32 tsize = GetTypeSize(); data.SetCount((start + count) * tsize * size); for(u32 i=start; i<start + count; ++i) { const u8* src = Memory.GetMemFromAddr(addr) + stride * i; u8* dst = &data[i * tsize * size]; switch(tsize) { case 1: { memcpy(dst, src, size); } break; case 2: { const u16* c_src = (const u16*)src; u16* c_dst = (u16*)dst; for(u32 j=0; j<size; ++j) *c_dst++ = re(*c_src++); } break; case 4: { const u32* c_src = (const u32*)src; u32* c_dst = (u32*)dst; for(u32 j=0; j<size; ++j) *c_dst++ = re(*c_src++); } break; } } }
void CNscContext::AddStructure (const char *pszIdentifier, unsigned char *pauchStructData, size_t nStructDataSize) { // // Make sure we still have room // if (m_nStructs >= Max_Structs) { GenerateError ("Too many defined structures, limit of %d", m_nStructs); return; } // // Add a new symbol // NscType nType = (NscType) (NscType_Struct_0 + m_nStructs); NscSymbol *pSymbol = m_sSymbols .Add ( pszIdentifier, NscSymType_Structure); pSymbol ->nType = nType; pSymbol ->ulFlags = 0; pSymbol ->nStackOffset = 0; size_t nSymbol = m_sSymbols .GetSymbolOffset (pSymbol); m_sSymCount ++; if (!IsNWScript() && m_fSymPrint) printf("Add struct symbol %s, count now %d\n", pszIdentifier, m_sSymCount); // // Count the number of elements // NscSymbolStructExtra sExtra; sExtra .nElementCount = 0; sExtra .nTotalSize = 0; unsigned char *pauchData = pauchStructData; unsigned char *pauchEnd = &pauchData [nStructDataSize]; while (pauchData < pauchEnd) { NscPCodeHeader *p = (NscPCodeHeader *) pauchData; sExtra .nElementCount++; sExtra .nTotalSize += GetTypeSize (p ->nType); pauchData += p ->nOpSize; } // // Add the symbol data // size_t nExtra = m_sSymbols .AppendData (&sExtra, sizeof (sExtra)); m_sSymbols .AppendData (pauchStructData, nStructDataSize); // // Save the data // m_sSymbols .GetSymbol (nSymbol) ->nExtra = nExtra; // // Save the symbol offset // m_anStructSymbol [m_nStructs++] = nSymbol; m_anGlobalDefs .Add (nSymbol); }
NscSymbol *CNscContext::AddPrototype (const char *pszIdentifier, NscType nType, UINT32 ulFlags, unsigned char *pauchArgData, size_t nArgDataSize) { // // Check for duplicate // NscSymbol *pSymbol = m_sSymbols .Find (pszIdentifier); if (pSymbol != NULL) return pSymbol; // // Add a new symbol // pSymbol = m_sSymbols .Add ( pszIdentifier, NscSymType_Function); pSymbol ->nType = nType; pSymbol ->ulFlags = ulFlags; pSymbol ->nStackOffset = 0; pSymbol ->nCompiledStart = 0xffffffff; pSymbol ->nCompiledEnd = 0xffffffff; size_t nSymbol = m_sSymbols .GetSymbolOffset (pSymbol); m_sSymCount ++; if (!IsNWScript() && m_fSymPrint) printf("Add prototype symbol %s, count now %d\n", pszIdentifier, m_sSymCount); // // Count the number of arguments // NscSymbolFunctionExtra sExtra; sExtra .nArgCount = 0; sExtra .nArgSize = 0; sExtra .nAction = 0; sExtra .nCodeOffset = 0; sExtra .nCodeSize = 0; sExtra .nFile = -1; sExtra .nLine = -1; unsigned char *pauchData = pauchArgData; unsigned char *pauchEnd = &pauchData [nArgDataSize]; while (pauchData < pauchEnd) { NscPCodeHeader *p = (NscPCodeHeader *) pauchData; sExtra .nArgCount++; sExtra .nArgSize += GetTypeSize (p ->nType); pauchData += p ->nOpSize; } // // If this is a global, then set the action // if ((ulFlags & NscSymFlag_EngineFunc) != 0) { g_anNscActions .Add (nSymbol); sExtra .nAction = g_nNscActionCount++; } // // Otherwise, add this function to the global symbol table // else if (IsPhase2 ()) { AddGlobalFunction (nSymbol); } // // Add the symbol data // size_t nExtra = m_sSymbols .AppendData (&sExtra, sizeof (sExtra)); m_sSymbols .AppendData (pauchArgData, nArgDataSize); // // Save the data // pSymbol = m_sSymbols .GetSymbol (nSymbol); pSymbol ->nExtra = nExtra; return pSymbol; }
BOOLEAN ObReadObject( _In_ ULONG64 Object, _Out_ PHANDLE_OBJECT HandleObj ) /*++ Routine Description: Description. Arguments: Object - HandleObj - Return Value: BOOLEAN. --*/ { BOOLEAN Result = FALSE; LPWSTR ObjName = NULL; ULONG BodyOffset = 0; GetFieldOffset("nt!_OBJECT_HEADER", "Body", &BodyOffset); WCHAR TypeStr[64] = { 0 }; if ((!Object) || (!IsValid(Object))) return FALSE; if (!ObTypeInit) { ObjTypeTable = ExtRemoteTyped("(nt!_OBJECT_TYPE **)@$extin", GetExpression("nt!ObTypeIndexTable")); ObTypeInit = TRUE; } ULONG64 ObjHeaderAddr = Object - BodyOffset; if (!IsValid(ObjHeaderAddr)) return FALSE; ExtRemoteTyped ObjHeader("(nt!_OBJECT_HEADER *)@$extin", ObjHeaderAddr); HandleObj->ObjectPtr = Object; // ObjHeader.Field("Body").GetPointerTo().GetPtr(); if (ObjHeader.HasField("TypeIndex")) { HandleObj->ObjectTypeIndex = ObjHeader.Field("TypeIndex").GetChar(); if ((HandleObj->ObjectTypeIndex <= 1) || (HandleObj->ObjectTypeIndex >= 45)) return FALSE; ExtRemoteTypedEx::GetUnicodeString(ObjTypeTable.ArrayElement(HandleObj->ObjectTypeIndex).Field("Name"), TypeStr, sizeof(TypeStr)); wcscpy_s(HandleObj->Type, TypeStr); } else { if (!IsValid(ObjHeader.Field("Type").GetPtr())) goto CleanUp; ExtRemoteTypedEx::GetUnicodeString(ObjHeader.Field("Type").Field("Name"), TypeStr, sizeof(TypeStr)); wcscpy_s(HandleObj->Type, TypeStr); } if (_wcsicmp(TypeStr, L"File") == 0) { ExtRemoteTyped FileObject("(nt!_FILE_OBJECT *)@$extin", HandleObj->ObjectPtr); ObjName = ExtRemoteTypedEx::GetUnicodeString2(FileObject.Field("FileName")); } else if (_wcsicmp(TypeStr, L"Driver") == 0) { ExtRemoteTyped DrvObject("(nt!_DRIVER_OBJECT *)@$extin", HandleObj->ObjectPtr); ObjName = ExtRemoteTypedEx::GetUnicodeString2(DrvObject.Field("DriverName")); } else if (_wcsicmp(TypeStr, L"Process") == 0) { ExtRemoteTyped ProcessObj("(nt!_EPROCESS *)@$extin", HandleObj->ObjectPtr); ObjName = ExtRemoteTypedEx::GetUnicodeString2(ProcessObj.Field("ImageFileName")); } else if (_wcsicmp(TypeStr, L"ALPC Port") == 0) { // dt nt!_ALPC_PORT } else if (_wcsicmp(TypeStr, L"EtwRegistration") == 0) { // dt nt!_ETW_? } else if (_wcsicmp(TypeStr, L"Thread") == 0) { // dt nt!_ETHREAD } else if (_wcsicmp(TypeStr, L"Event") == 0) { // dt nt!_KTHREAD } else if (_wcsicmp(TypeStr, L"Key") == 0) { ExtRemoteTyped KeyObject("(nt!_CM_KEY_BODY *)@$extin", HandleObj->ObjectPtr); HandleObj->ObjectKcb = KeyObject.Field("KeyControlBlock").GetPtr(); ObjName = RegGetKeyName(KeyObject.Field("KeyControlBlock")); // dt nt!_CM_KEY_BODY -> nt!_CM_KEY_CONTROL_BLOCK } else { ULONG Offset = 0; UCHAR InfoMask = 0; if (ObjHeader.HasField("InfoMask")) { InfoMask = ObjHeader.Field("InfoMask").GetUchar(); if (InfoMask & OBP_NAME_INFO_BIT) { if (InfoMask & OBP_CREATOR_INFO_BIT) Offset += GetTypeSize("nt!_OBJECT_HEADER_CREATOR_INFO"); Offset += GetTypeSize("nt!_OBJECT_HEADER_NAME_INFO"); } } else { Offset = ObjHeader.Field("NameInfoOffset").GetUchar(); } if (Offset) { ExtRemoteTyped ObjNameInfo("(nt!_OBJECT_HEADER_NAME_INFO *)@$extin", ObjHeaderAddr - Offset); ObjName = ExtRemoteTypedEx::GetUnicodeString2(ObjNameInfo.Field("Name")); } } if (ObjName) { wcscpy_s(HandleObj->Name, ObjName); free(ObjName); ObjName = NULL; } Result = TRUE; CleanUp: return Result; }
/****************************************************************************** * * * UINT GetTypeSize(TSYMTYPEDEF1 *pType1) * * * ******************************************************************************* * * Returns the size (in bytes) of the type's memory footprint. The type can * be any kind of type. * * Where: * pType1 is the type descriptor to get the memory footprint * * Returns: * Type memory footprint in bytes * 0 if the type is invalid for some reasons * ******************************************************************************/ UINT GetTypeSize(TSYMTYPEDEF1 *pType1) { TSYMTYPEDEF1 Type1; // Local type storage UINT nSize = 0; // Size variable char *pDef; // Pointer to the type definition // Make sure the given type descriptor is valid if( pType1 ) { // Copy the input type into the local store so we may modify it memcpy(&Type1, pType1, sizeof(TSYMTYPEDEF1)); // Get the local type into the canonical form - this will modify it TypedefCanonical(&Type1); // Simple - if there is any pointer redirection level, the final size is just the pointer size if( Type1.maj ) return( sizeof(void *) ); // Depending on the base type, find the size - built in types: if( *pType1->pDef <= TYPEDEF__LAST ) return( nSimpleTypes[*(BYTE *)pType1->pDef] ); // Get the new type definition... pDef = Type1.pDef; // We know we have a terminal type here - one of the complex types: switch( *pDef ) { case 'u': // Unions always keep the size in bits case 's': // Structures always keep the size in bytes pDef++; nSize = GetDec(&pDef); break; case 'e': // Consider enum an integer size case 'r': // A type that is a subrange of itself - right now we assume "int" nSize = sizeof(int); break; case 'a': // Array is most complicated since we need the size of a child * the number of elements { int lower, upper; // Array bounds pDef = strchr(pDef, ';'); // Find the first ';' to get to the bounds scan2dec(pDef+1, &lower, &upper); // Scan 2 decimal numbers "%d,%d" pDef = strchr(pDef, '('); // Find the trailing '(' to get to the child element // This will call itself recursively to get the size of one array element pType1 = Type2Typedef(pDef, 0, Type1.file_id); nSize = (upper-lower+1) * GetTypeSize(pType1); } break; default: ; // We should not be here... break; } } return( nSize ); }
/* * Get type size information. */ static void GetTypeSize(ILSizeInfo *info, ILType *type) { unsigned long num; unsigned long posn; /* Only complex types have a non-zero memory size */ if(type == 0 || !ILType_IsComplex(type)) { return; } /* Account for the size of the complex type header */ info->loadedMeta += sizeof(ILType); /* Account for element information */ switch(ILType_Kind(type)) { case IL_TYPE_COMPLEX_BYREF: case IL_TYPE_COMPLEX_PTR: case IL_TYPE_COMPLEX_PINNED: { GetTypeSize(info, ILType_Ref(type)); } break; case IL_TYPE_COMPLEX_ARRAY: case IL_TYPE_COMPLEX_ARRAY_CONTINUE: { GetTypeSize(info, ILType_ElemType(type)); } break; case IL_TYPE_COMPLEX_CMOD_REQD: case IL_TYPE_COMPLEX_CMOD_OPT: { GetTypeSize(info, type->un.modifier__.type__); } break; case IL_TYPE_COMPLEX_LOCALS: { num = ILTypeNumLocals(type); for(posn = 0; posn < num; ++posn) { GetTypeSize(info, ILTypeGetLocalWithPrefixes(type, posn)); } } break; case IL_TYPE_COMPLEX_WITH: { num = ILTypeNumWithParams(type); GetTypeSize(info, ILTypeGetWithMainWithPrefixes(type)); for(posn = 1; posn <= num; ++posn) { GetTypeSize(info, ILTypeGetWithParamWithPrefixes(type, posn)); } } break; case IL_TYPE_COMPLEX_PROPERTY: case IL_TYPE_COMPLEX_METHOD: case IL_TYPE_COMPLEX_METHOD | IL_TYPE_COMPLEX_METHOD_SENTINEL: { num = ILTypeNumParams(type); GetTypeSize(info, ILTypeGetReturnWithPrefixes(type)); for(posn = 1; posn <= num; ++posn) { GetTypeSize(info, ILTypeGetParamWithPrefixes(type, posn)); } } break; } }
/* * Get the metadata size information for a program item, * both on-disk and in-memory. */ static void GetMetadataSize(ILSizeInfo *info, ILProgramItem *item) { ILImage *image = ILProgramItem_Image(item); if(!item) { return; } info->meta += image->tokenSize[ILProgramItem_Token(item) >> 24]; switch(ILProgramItem_Token(item) & IL_META_TOKEN_MASK) { case IL_META_TOKEN_MODULE: GetStringSize(info, ILModule_Name((ILModule *)item)); info->meta += 16; /* GUID size */ info->loadedMeta += sizeof(ILModule); break; case IL_META_TOKEN_MODULE_REF: GetStringSize(info, ILModule_Name((ILModule *)item)); info->loadedMeta += sizeof(ILModule); break; case IL_META_TOKEN_TYPE_REF: info->loadedMeta += sizeof(ILClass); info->loadedMeta += sizeof(ILProgramItemLink); GetClassNameSize(info, (ILClass *)item); break; case IL_META_TOKEN_TYPE_DEF: info->loadedMeta += sizeof(ILClass); GetClassNameSize(info, (ILClass *)item); break; case IL_META_TOKEN_FIELD_DEF: info->loadedMeta += sizeof(ILField); GetStringSize(info, ILMember_Name(item)); GetBlobSize(info, item, ((ILMember *)item)->signatureBlob); GetTypeSize(info, ILMember_Signature(item)); break; case IL_META_TOKEN_METHOD_DEF: info->loadedMeta += sizeof(ILMethod); GetStringSize(info, ILMember_Name(item)); GetBlobSize(info, item, ((ILMember *)item)->signatureBlob); GetTypeSize(info, ILMember_Signature(item)); break; case IL_META_TOKEN_PARAM_DEF: info->loadedMeta += sizeof(ILParameter); GetStringSize(info, ILParameter_Name((ILParameter *)item)); break; case IL_META_TOKEN_INTERFACE_IMPL: info->loadedMeta += sizeof(ILImplements); break; case IL_META_TOKEN_MEMBER_REF: if(ILMemberGetKind((ILMember *)item) == IL_META_MEMBERKIND_METHOD) { info->loadedMeta += sizeof(ILMethod); } else { info->loadedMeta += sizeof(ILField); } info->loadedMeta += sizeof(ILProgramItemLink); GetStringSize(info, ILMember_Name(item)); GetBlobSize(info, item, ((ILMember *)item)->signatureBlob); GetTypeSize(info, ILMember_Signature(item)); break; case IL_META_TOKEN_CONSTANT: info->loadedMeta += sizeof(ILConstant); GetBlobSize(info, item, ((ILConstant *)item)->value); break; case IL_META_TOKEN_CUSTOM_ATTRIBUTE: info->loadedMeta += sizeof(ILAttribute); GetBlobSize(info, item, ((ILAttribute *)item)->value); break; case IL_META_TOKEN_FIELD_MARSHAL: info->loadedMeta += sizeof(ILFieldMarshal); GetBlobSize(info, item, ((ILFieldMarshal *)item)->type); break; case IL_META_TOKEN_DECL_SECURITY: info->loadedMeta += sizeof(ILDeclSecurity); GetBlobSize(info, item, ((ILDeclSecurity *)item)->blob); break; case IL_META_TOKEN_CLASS_LAYOUT: info->loadedMeta += sizeof(ILClassLayout); break; case IL_META_TOKEN_FIELD_LAYOUT: info->loadedMeta += sizeof(ILFieldLayout); break; case IL_META_TOKEN_STAND_ALONE_SIG: info->loadedMeta += sizeof(ILStandAloneSig); GetBlobSize(info, item, ((ILStandAloneSig *)item)->typeBlob); GetTypeSize(info, ((ILStandAloneSig *)item)->type); break; case IL_META_TOKEN_EVENT_MAP: info->loadedMeta += sizeof(ILEventMap); break; case IL_META_TOKEN_EVENT: info->loadedMeta += sizeof(ILEvent); break; case IL_META_TOKEN_PROPERTY_MAP: info->loadedMeta += sizeof(ILPropertyMap); break; case IL_META_TOKEN_PROPERTY: info->loadedMeta += sizeof(ILProperty); break; case IL_META_TOKEN_METHOD_SEMANTICS: info->loadedMeta += sizeof(ILMethodSem); break; case IL_META_TOKEN_METHOD_IMPL: info->loadedMeta += sizeof(ILOverride); break; case IL_META_TOKEN_TYPE_SPEC: info->loadedMeta += sizeof(ILTypeSpec); GetBlobSize(info, item, ((ILTypeSpec *)item)->typeBlob); GetTypeSize(info, ((ILTypeSpec *)item)->type); break; case IL_META_TOKEN_IMPL_MAP: info->loadedMeta += sizeof(ILPInvoke); GetStringSize(info, ILPInvoke_Alias((ILPInvoke *)item)); break; case IL_META_TOKEN_FIELD_RVA: info->loadedMeta += sizeof(ILFieldRVA); break; case IL_META_TOKEN_ASSEMBLY: info->loadedMeta += sizeof(ILAssembly); GetStringSize(info, ILAssembly_Name((ILAssembly *)item)); GetStringSize(info, ILAssembly_Locale((ILAssembly *)item)); break; case IL_META_TOKEN_ASSEMBLY_REF: info->loadedMeta += sizeof(ILAssembly); info->loadedMeta += sizeof(ILProgramItemLink); GetStringSize(info, ILAssembly_Name((ILAssembly *)item)); GetStringSize(info, ILAssembly_Locale((ILAssembly *)item)); break; case IL_META_TOKEN_PROCESSOR_DEF: case IL_META_TOKEN_PROCESSOR_REF: info->loadedMeta += sizeof(ILProcessorInfo); break; case IL_META_TOKEN_OS_DEF: case IL_META_TOKEN_OS_REF: info->loadedMeta += sizeof(ILOSInfo); break; case IL_META_TOKEN_FILE: info->loadedMeta += sizeof(ILFileDecl); GetStringSize(info, ILFileDecl_Name((ILFileDecl *)item)); GetBlobSize(info, item, ((ILFileDecl *)item)->hash); break; case IL_META_TOKEN_EXPORTED_TYPE: info->loadedMeta += sizeof(ILExportedType); info->loadedMeta += sizeof(ILProgramItemLink); GetClassNameSize(info, (ILClass *)item); break; case IL_META_TOKEN_MANIFEST_RESOURCE: info->loadedMeta += sizeof(ILManifestRes); GetStringSize(info, ILManifestRes_Name((ILManifestRes *)item)); break; case IL_META_TOKEN_NESTED_CLASS: info->loadedMeta += sizeof(ILNestedInfo); break; case IL_META_TOKEN_GENERIC_PAR: info->loadedMeta += sizeof(ILGenericPar); GetStringSize(info, ILGenericPar_Name((ILGenericPar *)item)); break; case IL_META_TOKEN_METHOD_SPEC: info->loadedMeta += sizeof(ILMethodSpec); GetBlobSize(info, item, ((ILMethodSpec *)item)->typeBlob); GetTypeSize(info, ((ILMethodSpec *)item)->type); break; } }
void CSearchDlg::StartNewSearch() { static uint32 m_nSearchID = 0; m_nSearchID++; FindWindow(IDC_STARTS)->Disable(); FindWindow(IDC_SDOWNLOAD)->Disable(); FindWindow(IDC_CANCELS)->Enable(); CSearchList::CSearchParams params; params.searchString = CastChild( IDC_SEARCHNAME, wxTextCtrl )->GetValue(); params.searchString.Trim(true); params.searchString.Trim(false); if (params.searchString.IsEmpty()) { return; } if (CastChild(IDC_EXTENDEDSEARCHCHECK, wxCheckBox)->GetValue()) { params.extension = CastChild( IDC_EDITSEARCHEXTENSION, wxTextCtrl )->GetValue(); uint32 sizemin = GetTypeSize( (uint8) CastChild( IDC_SEARCHMINSIZE, wxChoice )->GetSelection() ); uint32 sizemax = GetTypeSize( (uint8) CastChild( IDC_SEARCHMAXSIZE, wxChoice )->GetSelection() ); // Parameter Minimum Size params.minSize = (uint64_t)(CastChild( IDC_SPINSEARCHMIN, wxSpinCtrl )->GetValue()) * (uint64_t)sizemin; // Parameter Maximum Size params.maxSize = (uint64_t)(CastChild( IDC_SPINSEARCHMAX, wxSpinCtrl )->GetValue()) * (uint64_t)sizemax; if ((params.maxSize < params.minSize) && (params.maxSize)) { wxMessageDialog dlg(this, _("Min size must be smaller than max size. Max size ignored."), _("Search warning"), wxOK|wxCENTRE|wxICON_INFORMATION); dlg.ShowModal(); params.maxSize = 0; } // Parameter Availability params.availability = CastChild( IDC_SPINSEARCHAVAIBILITY, wxSpinCtrl )->GetValue(); switch ( CastChild( IDC_TypeSearch, wxChoice )->GetSelection() ) { case 0: params.typeText.Clear(); break; case 1: params.typeText = ED2KFTSTR_ARCHIVE; break; case 2: params.typeText = ED2KFTSTR_AUDIO; break; case 3: params.typeText = ED2KFTSTR_CDIMAGE; break; case 4: params.typeText = ED2KFTSTR_IMAGE; break; case 5: params.typeText = ED2KFTSTR_PROGRAM; break; case 6: params.typeText = ED2KFTSTR_DOCUMENT; break; case 7: params.typeText = ED2KFTSTR_VIDEO; break; default: AddDebugLogLineC( logGeneral, CFormat( wxT("Warning! Unknown search-category (%s) selected!") ) % params.typeText ); break; } } SearchType search_type = KadSearch; int selection = CastChild( ID_SEARCHTYPE, wxChoice )->GetSelection(); if (!thePrefs::GetNetworkED2K()) { selection += 2; } if (!thePrefs::GetNetworkKademlia()) { selection += 1; } switch (selection) { case 0: // Local Search search_type = LocalSearch; break; case 1: // Global Search search_type = GlobalSearch; break; case 2: // Kad search search_type = KadSearch; break; default: // Should never happen wxFAIL; break; } uint32 real_id = m_nSearchID; wxString error = theApp->searchlist->StartNewSearch(&real_id, search_type, params); if (!error.IsEmpty()) { // Search failed / Remote in progress wxMessageBox(error, _("Search warning"), wxOK | wxCENTRE | wxICON_INFORMATION, this); FindWindow(IDC_STARTS)->Enable(); FindWindow(IDC_SDOWNLOAD)->Disable(); FindWindow(IDC_CANCELS)->Disable(); } else { CreateNewTab( ((search_type == KadSearch) ? wxT("!") : wxEmptyString) + params.searchString + wxT(" (0)"), real_id); } }
static bool DeserializeObject(CLR_RT_HeapBlock* pObj, CLR_UINT8* serData, CLR_INT32& serOffset, const CLR_INT32 serSize ) { if(pObj == NULL) { return false; } switch(pObj->DataType()) { case DATATYPE_OBJECT: if(!DeserializeObject(pObj->Dereference(), serData, serOffset, serSize)) return false; break; case DATATYPE_CLASS: case DATATYPE_VALUETYPE: { CLR_RT_TypeDef_Instance cls; cls.InitializeFromIndex( pObj->ObjectCls() ); int totFields = cls.CrossReference().m_totalFields; while(totFields-- > 0) { if(!DeserializeObject( ++pObj, serData, serOffset, serSize )) return false; } } break; case DATATYPE_SZARRAY: { CLR_RT_HeapBlock_Array* array = (CLR_RT_HeapBlock_Array*)pObj; int cnt = array->m_numOfElements; if(array->m_typeOfElement <= DATATYPE_LAST_NONPOINTER && cnt < 256) { CLR_UINT8* pData = (CLR_UINT8*)array->GetFirstElement(); int nativeSize = GetTypeSize((CLR_DataType)array->m_typeOfElement); if(nativeSize <= 0) return false; while(cnt--) { int size = nativeSize; int i = 0; while(size--) { #ifndef BIG_ENDIAN pData[i++ ] = serData[serOffset++]; #else pData[size] = serData[serOffset++]; #endif } pData += array->m_sizeOfElement; } } else { return false; } } break; default: { CLR_UINT64 data = (CLR_UINT64)pObj->NumericByRef().u8; if(!DeserializeIntrinsicType(pObj, serData, serOffset, serSize)) return false; } break; } return true; }
void CreateYCSBDatabase() { const oid_t col_count = state.column_count + 1; const bool is_inlined = true; ///////////////////////////////////////////////////////// // Create tables ///////////////////////////////////////////////////////// // Clean up delete ycsb_database; ycsb_database = nullptr; user_table = nullptr; auto &manager = catalog::Manager::GetInstance(); ycsb_database = new storage::Database(ycsb_database_oid); manager.AddDatabase(ycsb_database); bool own_schema = true; bool adapt_table = false; // Create schema first std::vector<catalog::Column> columns; auto column = catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "YCSB_KEY", is_inlined); columns.push_back(column); for (oid_t col_itr = 1; col_itr < col_count; col_itr++) { auto column = catalog::Column(VALUE_TYPE_INTEGER, ycsb_field_length, "FIELD" + std::to_string(col_itr), is_inlined); columns.push_back(column); } catalog::Schema *table_schema = new catalog::Schema(columns); std::string table_name("USERTABLE"); user_table = storage::TableFactory::GetDataTable( ycsb_database_oid, user_table_oid, table_schema, table_name, 1000, own_schema, adapt_table); ycsb_database->AddTable(user_table); // Primary index on user key std::vector<oid_t> key_attrs; auto tuple_schema = user_table->GetSchema(); catalog::Schema *key_schema; index::IndexMetadata *index_metadata; bool unique; key_attrs = {0}; key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); key_schema->SetIndexedColumns(key_attrs); unique = true; index_metadata = new index::IndexMetadata( "primary_index", user_table_pkey_index_oid, INDEX_TYPE_BTREE, INDEX_CONSTRAINT_TYPE_INVALID, tuple_schema, key_schema, unique); index::Index *pkey_index = index::IndexFactory::GetInstance(index_metadata); user_table->AddIndex(pkey_index); }
Offset<const Table *> CopyTable(FlatBufferBuilder &fbb, const reflection::Schema &schema, const reflection::Object &objectdef, const Table &table, bool use_string_pooling) { // Before we can construct the table, we have to first generate any // subobjects, and collect their offsets. std::vector<uoffset_t> offsets; auto fielddefs = objectdef.fields(); for (auto it = fielddefs->begin(); it != fielddefs->end(); ++it) { auto &fielddef = **it; // Skip if field is not present in the source. if (!table.CheckField(fielddef.offset())) continue; uoffset_t offset = 0; switch (fielddef.type()->base_type()) { case reflection::String: { offset = use_string_pooling ? fbb.CreateSharedString(GetFieldS(table, fielddef)).o : fbb.CreateString(GetFieldS(table, fielddef)).o; break; } case reflection::Obj: { auto &subobjectdef = *schema.objects()->Get(fielddef.type()->index()); if (!subobjectdef.is_struct()) { offset = CopyTable(fbb, schema, subobjectdef, *GetFieldT(table, fielddef)).o; } break; } case reflection::Union: { auto &subobjectdef = GetUnionType(schema, objectdef, fielddef, table); offset = CopyTable(fbb, schema, subobjectdef, *GetFieldT(table, fielddef)).o; break; } case reflection::Vector: { auto vec = table.GetPointer<const Vector<Offset<Table>> *>( fielddef.offset()); auto element_base_type = fielddef.type()->element(); auto elemobjectdef = element_base_type == reflection::Obj ? schema.objects()->Get(fielddef.type()->index()) : nullptr; switch (element_base_type) { case reflection::String: { std::vector<Offset<const String *>> elements(vec->size()); auto vec_s = reinterpret_cast<const Vector<Offset<String>> *>(vec); for (uoffset_t i = 0; i < vec_s->size(); i++) { elements[i] = use_string_pooling ? fbb.CreateSharedString(vec_s->Get(i)).o : fbb.CreateString(vec_s->Get(i)).o; } offset = fbb.CreateVector(elements).o; break; } case reflection::Obj: { if (!elemobjectdef->is_struct()) { std::vector<Offset<const Table *>> elements(vec->size()); for (uoffset_t i = 0; i < vec->size(); i++) { elements[i] = CopyTable(fbb, schema, *elemobjectdef, *vec->Get(i)); } offset = fbb.CreateVector(elements).o; break; } } // FALL-THRU default: { // Scalars and structs. auto element_size = GetTypeSize(element_base_type); if (elemobjectdef && elemobjectdef->is_struct()) element_size = elemobjectdef->bytesize(); fbb.StartVector(element_size, vec->size()); fbb.PushBytes(vec->Data(), element_size * vec->size()); offset = fbb.EndVector(vec->size()); break; } } break; } default: // Scalars. break; } if (offset) { offsets.push_back(offset); } } // Now we can build the actual table from either offsets or scalar data. auto start = objectdef.is_struct() ? fbb.StartStruct(objectdef.minalign()) : fbb.StartTable(); size_t offset_idx = 0; for (auto it = fielddefs->begin(); it != fielddefs->end(); ++it) { auto &fielddef = **it; if (!table.CheckField(fielddef.offset())) continue; auto base_type = fielddef.type()->base_type(); switch (base_type) { case reflection::Obj: { auto &subobjectdef = *schema.objects()->Get(fielddef.type()->index()); if (subobjectdef.is_struct()) { CopyInline(fbb, fielddef, table, subobjectdef.minalign(), subobjectdef.bytesize()); break; } } // ELSE FALL-THRU case reflection::Union: case reflection::String: case reflection::Vector: fbb.AddOffset(fielddef.offset(), Offset<void>(offsets[offset_idx++])); break; default: { // Scalars. auto size = GetTypeSize(base_type); CopyInline(fbb, fielddef, table, size, size); break; } } } assert(offset_idx == offsets.size()); if (objectdef.is_struct()) { fbb.ClearOffsets(); return fbb.EndStruct(); } else { return fbb.EndTable(start, static_cast<voffset_t>(fielddefs->size())); } }
vector<NETWORK_ENTRY> GetSockets( ) /*++ Routine Description: Description. Arguments: - Return Value: vector<NETWORK_ENTRY>. --*/ { ULONG64 TableAddr; ULONG64 TableCountAddr; PULONG64 Table = NULL; ULONG TableCount; vector<NETWORK_ENTRY> NetworkEntries; ULONG ProcessorType; ULONG PlateformId, Major, Minor, ServicePackNumber; if (g_Ext->m_Control->GetActualProcessorType(&ProcessorType) != S_OK) goto CleanUp; if (g_Ext->m_Control->GetSystemVersion(&PlateformId, &Major, &Minor, NULL, NULL, NULL, &ServicePackNumber, NULL, NULL, NULL) != S_OK) goto CleanUp; // g_Ext->Dml("Major: %d, Minor: %d, ProcessorType = %x\n", Major, Minor, ProcessorType); if ((Minor < 6000) && (ProcessorType == IMAGE_FILE_MACHINE_I386)) { if (g_Ext->m_Symbols->GetOffsetByName("tcpip!AddrObjTable", &TableAddr) != S_OK) goto CleanUp; if (g_Ext->m_Symbols->GetOffsetByName("tcpip!AddrObjTableSize", &TableCountAddr) != S_OK) goto CleanUp; if (ReadPointersVirtual(1, TableAddr, &TableAddr) != S_OK) goto CleanUp; if (g_Ext->m_Data->ReadVirtual(TableCountAddr, &TableCount, sizeof(ULONG), NULL) != S_OK) goto CleanUp; Table = (PULONG64)malloc(TableCount * sizeof(ULONG64)); if (ReadPointersVirtual(TableCount, TableAddr, Table) != S_OK) goto CleanUp; for (UINT i = 0; i < TableCount; i += 1) { Network::OBJECT_ENTRY_X86 ObjectEntry = { 0 }; NETWORK_ENTRY NetworkEntry = { 0 }; if (Table[i] == 0) continue; if (g_Ext->m_Data->ReadVirtual(Table[i], &ObjectEntry, sizeof(Network::OBJECT_ENTRY_X86), NULL) != S_OK) goto CleanUp; NetworkEntry.ObjectPtr = Table[i]; NetworkEntry.CreationTime = ObjectEntry.CreationTime; NetworkEntry.ProcessId = ObjectEntry.ProcessId; NetworkEntry.Protocol = ObjectEntry.Protocol; NetworkEntry.Local.Port = (ObjectEntry.Port[1] << 8) | ObjectEntry.Port[0]; NetworkEntry.Local.IPv4_Addr[3] = ObjectEntry.LocalAddress[3]; NetworkEntry.Local.IPv4_Addr[2] = ObjectEntry.LocalAddress[2]; NetworkEntry.Local.IPv4_Addr[1] = ObjectEntry.LocalAddress[1]; NetworkEntry.Local.IPv4_Addr[0] = ObjectEntry.LocalAddress[0]; NetworkEntry.State = TcbListenState; NetworkEntries.push_back(NetworkEntry); } } else if (Minor > 6000) { if (g_Ext->m_Symbols->GetOffsetByName("tcpip!PartitionCount", &TableCountAddr) != S_OK) goto CleanUp; ReadPointer(GetExpression("tcpip!PartitionTable"), &TableAddr); if (!TableAddr) goto CleanUp; if (g_Ext->m_Data->ReadVirtual(TableCountAddr, &TableCount, sizeof(ULONG), NULL) != S_OK) goto CleanUp; ULONG ListEntrySize = GetTypeSize("nt!_LIST_ENTRY"); ULONG PoolHeaderSize = GetTypeSize("nt!_POOL_HEADER"); ExtRemoteUnTyped PartitionTable(TableAddr, "tcpip!_PARTITION_TABLE"); for (UINT PartitionIndex = 0; PartitionIndex < TableCount; PartitionIndex += 1) { NETWORK_ENTRY NetworkEntry = { 0 }; // g_Ext->Dml(" -> Partition[%d].HashTables = 0x%I64X\n", PartitionIndex, Partition->HashTables); ExtRemoteTyped HashTable("(nt!_RTL_DYNAMIC_HASH_TABLE *)@$extin", PartitionTable.ArrayElement(PartitionIndex).Field("HashTables").GetPtr()); ULONG64 Directory = HashTable.Field("Directory").GetPtr(); ULONG TableEntries = HashTable.Field("TableSize").GetUlong(); for (UINT i = 0; i < TableEntries; i += 1) { ExtRemoteTypedList List(Directory + i * ListEntrySize, "nt!_LIST_ENTRY", "Flink"); for (List.StartHead(); List.HasNode(); List.Next()) { ULONG64 Current = List.GetNodeOffset(); if (!IsValid(Current)) break; ExtRemoteUnTyped Tcb(Current, "tcpip!_TCB"); Tcb.SubtractOffset("HashTableEntry"); ExtRemoteTyped PoolHeader("(nt!_POOL_HEADER *)@$extin", Tcb.GetPointerTo() - PoolHeaderSize); if (PoolHeader.Field("PoolTag").GetUlong() != 'EpcT') continue; //# Seen as 0x1f0 on Vista SP0, 0x1f8 on Vista SP2 and 0x210 on 7 //# Seen as 0x320 on Win7 SP0 x64 ULONG PoolSize; if (PoolHeader.Field("BlockSize").GetTypeSize() == sizeof(USHORT)) { PoolSize = PoolHeader.Field("BlockSize").GetUshort() * 0x10; } else { PoolSize = PoolHeader.Field("BlockSize").GetUlong() * 0x10; } if (PoolSize < 0x100) continue; ULONG64 SrcAddress = 0; ULONG64 DstAddress = 0; NetworkEntry.Protocol = PROTOCOL_TCP; NetworkEntry.State = Tcb.Field("State").GetUlong(); NetworkEntry.Local.Port = Tcb.Field("LocalPort").GetUshort(); NetworkEntry.Remote.Port = Tcb.Field("RemotePort").GetUshort(); DstAddress = Tcb.Field("Path", TRUE).Field("DestinationAddress").GetPtr(); if (IsValid(Tcb.Field("Path").GetPtr() && IsValid(Tcb.Field("Path", TRUE).Field("SourceAddress").GetPtr()) && IsValid(Tcb.Field("Path", TRUE).Field("SourceAddress", TRUE).Field("Identifier").GetPtr()) && IsValid(Tcb.Field("Path", TRUE).Field("SourceAddress", TRUE).Field("Identifier", TRUE).Field("Address").GetPtr()))) { SrcAddress = Tcb.Field("Path", TRUE).Field("SourceAddress", TRUE).Field("Identifier", TRUE).Field("Address").GetPtr(); } if (DstAddress && g_Ext->m_Data->ReadVirtual(DstAddress, &NetworkEntry.Remote.IPv4_Addr, sizeof(NetworkEntry.Remote.IPv4_Addr), NULL) != S_OK) goto CleanUp; if (SrcAddress && g_Ext->m_Data->ReadVirtual(SrcAddress, &NetworkEntry.Local.IPv4_Addr, sizeof(NetworkEntry.Local.IPv4_Addr), NULL) != S_OK) goto CleanUp; ExtRemoteTyped OwningProcess("(nt!_EPROCESS *)@$extin", Tcb.Field("OwningProcess").GetPtr()); NetworkEntry.ProcessId = OwningProcess.Field("UniqueProcessId").GetPtr(); OwningProcess.Field("ImageFileName").GetString((LPSTR)NetworkEntry.ProcessName, sizeof(NetworkEntry.ProcessName)); NetworkEntries.push_back(NetworkEntry); } } } } CleanUp: if (Table) free(Table); return NetworkEntries; }
void WDbgArk::InitCallbackCommands(void) { // TODO(swwwolf): optimize by calculating offsets in constructor only once // init systemcb map SystemCbCommand command_info = { "nt!PspLoadImageNotifyRoutineCount", "nt!PspLoadImageNotifyRoutine", 0 }; system_cb_commands["image"] = command_info; command_info.list_count_name = "nt!PspCreateProcessNotifyRoutineCount"; command_info.list_head_name = "nt!PspCreateProcessNotifyRoutine"; system_cb_commands["process"] = command_info; command_info.list_count_name = "nt!PspCreateThreadNotifyRoutineCount"; command_info.list_head_name = "nt!PspCreateThreadNotifyRoutine"; system_cb_commands["thread"] = command_info; command_info.list_count_name = "nt!CmpCallBackCount"; command_info.list_head_name = "nt!CmpCallBackVector"; command_info.offset_to_routine = GetCmCallbackItemFunctionOffset(); system_cb_commands["registry"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!KeBugCheckCallbackListHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY"); system_cb_commands["bugcheck"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!KeBugCheckReasonCallbackListHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY"); system_cb_commands["bugcheckreason"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!KeBugCheckAddPagesCallbackListHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY"); system_cb_commands["bugcheckaddpages"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!PopRegisteredPowerSettingCallbacks"; command_info.offset_to_routine = GetPowerCallbackItemFunctionOffset(); system_cb_commands["powersetting"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = ""; command_info.offset_to_routine = 0; system_cb_commands["callbackdir"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!IopNotifyShutdownQueueHead"; system_cb_commands["shutdown"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!IopNotifyLastChanceShutdownQueueHead"; system_cb_commands["shutdownlast"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!IopDriverReinitializeQueueHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY") + m_PtrSize; system_cb_commands["drvreinit"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!IopBootDriverReinitializeQueueHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY") + m_PtrSize; system_cb_commands["bootdrvreinit"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!IopFsNotifyChangeQueueHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY") + m_PtrSize; system_cb_commands["fschange"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!KiNmiCallbackListHead"; command_info.offset_to_routine = m_PtrSize; system_cb_commands["nmi"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!SeFileSystemNotifyRoutinesHead"; command_info.offset_to_routine = m_PtrSize; system_cb_commands["logonsessionroutine"] = command_info; command_info.list_count_name = "nt!IopUpdatePriorityCallbackRoutineCount"; command_info.list_head_name = "nt!IopUpdatePriorityCallbackRoutine"; command_info.offset_to_routine = 0; system_cb_commands["prioritycallback"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = ""; system_cb_commands["pnp"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!PspLegoNotifyRoutine"; // actually just a pointer system_cb_commands["lego"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!RtlpDebugPrintCallbackList"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY"); system_cb_commands["debugprint"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!AlpcpLogCallbackListHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY"); system_cb_commands["alpcplog"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!EmpCallbackListHead"; command_info.offset_to_routine = GetTypeSize("nt!_GUID"); system_cb_commands["empcb"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!IopPerfIoTrackingListHead"; command_info.offset_to_routine = GetTypeSize("nt!_LIST_ENTRY"); system_cb_commands["ioperf"] = command_info; command_info.list_count_name = ""; command_info.list_head_name = "nt!DbgkLkmdCallbackArray"; command_info.offset_to_routine = 0; system_cb_commands["dbgklkmd"] = command_info; }
void ExecuteTileGroupTest() { const int tuples_per_tilegroup_count = 10; const int tile_group_count = 5; const int tuple_count = tuples_per_tilegroup_count * tile_group_count; const oid_t col_count = 250; const bool is_inlined = true; const bool indexes = false; std::vector<catalog::Column> columns; for (oid_t col_itr = 0; col_itr <= col_count; col_itr++) { auto column = catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "FIELD" + std::to_string(col_itr), is_inlined); columns.push_back(column); } catalog::Schema *table_schema = new catalog::Schema(columns); std::string table_name("TEST_TABLE"); ///////////////////////////////////////////////////////// // Create table. ///////////////////////////////////////////////////////// bool own_schema = true; bool adapt_table = true; std::unique_ptr<storage::DataTable> table(storage::TableFactory::GetDataTable( INVALID_OID, INVALID_OID, table_schema, table_name, tuples_per_tilegroup_count, own_schema, adapt_table)); // PRIMARY INDEX if (indexes == true) { std::vector<oid_t> key_attrs; auto tuple_schema = table->GetSchema(); catalog::Schema *key_schema; index::IndexMetadata *index_metadata; bool unique; key_attrs = {0}; key_schema = catalog::Schema::CopySchema(tuple_schema, key_attrs); key_schema->SetIndexedColumns(key_attrs); unique = true; index_metadata = new index::IndexMetadata( "primary_index", 123, INDEX_TYPE_BTREE, INDEX_CONSTRAINT_TYPE_PRIMARY_KEY, tuple_schema, key_schema, unique); index::Index *pkey_index = index::IndexFactory::GetInstance(index_metadata); table->AddIndex(pkey_index); } ///////////////////////////////////////////////////////// // Load in the data ///////////////////////////////////////////////////////// // Insert tuples into tile_group. auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance(); const bool allocate = true; auto txn = txn_manager.BeginTransaction(); auto testing_pool = TestingHarness::GetInstance().GetTestingPool(); for (int rowid = 0; rowid < tuple_count; rowid++) { int populate_value = rowid; storage::Tuple tuple(table_schema, allocate); for (oid_t col_itr = 0; col_itr <= col_count; col_itr++) { auto value = ValueFactory::GetIntegerValue(populate_value + col_itr); tuple.SetValue(col_itr, value, testing_pool); } ItemPointer tuple_slot_id = table->InsertTuple(&tuple); EXPECT_TRUE(tuple_slot_id.block != INVALID_OID); EXPECT_TRUE(tuple_slot_id.offset != INVALID_OID); txn_manager.PerformInsert(tuple_slot_id.block, tuple_slot_id.offset); } txn_manager.CommitTransaction(); ///////////////////////////////////////////////////////// // Do a seq scan with predicate on top of the table ///////////////////////////////////////////////////////// txn = txn_manager.BeginTransaction(); std::unique_ptr<executor::ExecutorContext> context( new executor::ExecutorContext(txn)); // Column ids to be added to logical tile after scan. // std::vector<oid_t> column_ids; // for(oid_t col_itr = 0 ; col_itr <= 200; col_itr++) { // column_ids.push_back(col_itr); //} std::vector<oid_t> column_ids({198, 206}); // Create and set up seq scan executor planner::SeqScanPlan seq_scan_node(table.get(), nullptr, column_ids); int expected_num_tiles = tile_group_count; executor::SeqScanExecutor seq_scan_executor(&seq_scan_node, context.get()); // Create and set up materialization executor std::vector<catalog::Column> output_columns; std::unordered_map<oid_t, oid_t> old_to_new_cols; oid_t col_itr = 0; for (auto column_id : column_ids) { auto column = catalog::Column(VALUE_TYPE_INTEGER, GetTypeSize(VALUE_TYPE_INTEGER), "FIELD" + std::to_string(column_id), is_inlined); output_columns.push_back(column); old_to_new_cols[col_itr] = col_itr; col_itr++; } std::unique_ptr<catalog::Schema> output_schema( new catalog::Schema(output_columns)); bool physify_flag = true; // is going to create a physical tile planner::MaterializationPlan mat_node(old_to_new_cols, output_schema.release(), physify_flag); executor::MaterializationExecutor mat_executor(&mat_node, nullptr); mat_executor.AddChild(&seq_scan_executor); EXPECT_TRUE(mat_executor.Init()); std::vector<std::unique_ptr<executor::LogicalTile>> result_tiles; for (int i = 0; i < expected_num_tiles; i++) { EXPECT_TRUE(mat_executor.Execute()); std::unique_ptr<executor::LogicalTile> result_tile( mat_executor.GetOutput()); EXPECT_THAT(result_tile, NotNull()); result_tiles.emplace_back(result_tile.release()); } EXPECT_FALSE(mat_executor.Execute()); txn_manager.CommitTransaction(); }
size_t GetSize() const { return GetTypeSize(m_type); }